@zama-fhe/sdk 3.7.0-alpha.2 → 3.7.0-beta.2

package/dist/esm/query/index.d.ts

@@ -1,4 +1,495 @@
-import { f as FheChain, p as FheChainAuth } from "../index-Gk1S0gjO.js";
-import { $ as RevokeDelegationSubmittedEvent, $t as TransactionResult, A as WalletAccountListener, At as OnChainEvent, B as ApproveUnderlyingSubmittedEvent, C as TransferAndCallRequest, Ct as TransferCallbacks, D as GenericSigner, E as WrapRequest, F as ReadContractReturnType, Ft as UnwrapRequestedEvent, G as DelegationSubmittedEvent, H as DecryptEndEvent, I as ReadFunctionName, It as WrapEvent, J as EncryptStartEvent, K as EncryptEndEvent, L as WriteContractArgs, M as ContractAbi, N as ReadContractArgs, O as WalletAccount, Ot as ConfidentialTransferEvent, P as ReadContractConfig, Pt as UnwrapFinalizedEvent, Q as PermitOperation, Qt as TransactionReceipt, R as WriteContractConfig, S as TransactionKind, St as ShieldCallbacks, T as UnwrapRequest, U as DecryptErrorEvent, V as BaseEvent, W as DecryptStartEvent, X as InvalidateDecryptionSignaturesSubmittedEvent, Y as FinalizeUnwrapSubmittedEvent, Z as PermitErrorEvent, Zt as RawLog, _ as PrepareTransactionRequest, _t as ShieldPath, an as EncryptParams, at as TransferSubmittedEvent, b as RevokeDelegationRequest, bt as UnwrapResult, c as GenericStorage, cn as FhevmClient, ct as UnshieldPhase2SubmittedEvent, d as ConfidentialTransferFromRequest, dn as FhevmRuntimeConfig, dt as ZamaSDKEvent, en as ClearValue, et as SetOperatorSubmittedEvent, f as ConfidentialTransferRequest, ft as ZamaSDKEventListener, g as PrepareOptions, gt as ShieldOptions, h as PrepareFees, ht as ApprovalStrategy, i as ZamaConfig, in as EncryptInput, it as TransferFromSubmittedEvent, j as WalletAccountStore, k as WalletAccountChange, l as GenericProvider, lt as UnwrapSubmittedEvent, m as FinalizeUnwrapRequest, mt as ZamaSDKEvents, nt as TransactionErrorEvent, on as EncryptResult, ot as UnshieldPhase1SubmittedEvent, p as DelegateDecryptionRequest, pn as RelayerSDK, q as EncryptErrorEvent, rn as EIP712TypedData, rt as TransactionOperation, s as GenericLogger, sn as EncryptedValue, st as UnshieldPhase2StartedEvent, tn as DecryptPublicValuesResult, tt as ShieldSubmittedEvent, u as ApproveUnderlyingRequest, un as FhevmRelayerOptions, ut as WrapSubmittedEvent, v as PreparedFor, vt as TransferOptions, w as UnwrapAllRequest, wt as UnshieldCallbacks, x as SetOperatorRequest, xt as WrapOptions, y as PreparedTransaction, yt as UnshieldOptions, z as WriteFunctionName } from "../types-BOyFfG7D.js";
-import { $ as confidentialTransferFromAndCallMutationOptions, $t as QueryLike, A as grantPermitMutationOptions, Ar as SerializedPermitEip712, At as Token, B as UnwrapParams, Bt as ListPairsOptions, C as clearCredentialsMutationOptions, Ct as ConfidentialBalancesQueryConfig, D as RegisterPermitParams, Dr as PreparedPermitV1, Dt as WrappedToken, E as hasPermitQueryOptions, Er as PreparedPermitBase, Et as confidentialBalanceQueryOptions, F as FinalizeUnwrapParams, Fr as PaginatedResult, Ft as UnderlyingAllowanceQueryConfig, G as unshieldAllMutationOptions, Gt as IsConfidentialQueryConfig, H as ResumeUnshieldParams, Ht as WrappersRegistryConfig, I as finalizeUnwrapMutationOptions, Ir as TokenWrapperPair, It as underlyingAllowanceQueryOptions, J as ApproveUnderlyingParams, Jt as TokenMetadata, K as UnshieldParams, Kt as isConfidentialQueryOptions, L as unwrapAllMutationOptions, Lr as TokenWrapperPairWithMetadata, Lt as WrapperDiscoveryQueryConfig, M as DelegatedDecryptValuesMutationParams, Mr as WILDCARD_PERMIT, Mt as confidentialIsOperatorQueryOptions, N as delegatedDecryptValuesMutationOptions, Nr as WildcardPermit, Nt as PendingUnshieldQueryConfig, O as registerPermitMutationOptions, Or as PreparedPermitV2, Ot as BatchBalancesResult, P as encryptMutationOptions, Pr as ChecksummedAddress, Pt as pendingUnshieldQueryOptions, Q as ConfidentialTransferFromAndCallParams, Qt as QueryFilterLike, R as WrapParams, Rt as wrapperDiscoveryQueryOptions, S as delegateDecryptionMutationOptions, St as tokenPairsSliceQueryOptions, T as HasPermitQueryConfig, Tr as PreparedPermit, Tt as ConfidentialBalanceQueryConfig, U as resumeUnshieldMutationOptions, Ut as TotalSupplyQueryConfig, V as unwrapMutationOptions, Vt as WrappersRegistry, W as UnshieldAllParams, Wt as totalSupplyQueryOptions, X as ConfidentialSetOperatorParams, Xt as tokenMetadataQueryOptions, Y as approveUnderlyingMutationOptions, Yt as TokenMetadataQueryConfig, Z as confidentialSetOperatorMutationOptions, Zt as QueryClientLike, _ as BatchDecryptBalancesAsParams, _n as hashFn, _r as ZamaErrorCode, _t as listPairsQueryOptions, a as ZamaSDK, an as invalidateAfterUnshieldSettled, at as confidentialTransferMutationOptions, b as decryptBalanceAsMutationOptions, bn as Permits, bt as tokenPairsLengthQueryOptions, c as BatchDecryptItem, cn as invalidateBalanceQueries, ct as ConfidentialTokenAddressQueryConfig, d as DelegationStatusQueryConfig, dn as zamaQueryKeys, dt as TokenAddressQueryConfig, en as invalidateAfterApproveUnderlying, et as ConfidentialTransferFromParams, f as delegationStatusQueryOptions, fn as SignerQueryContext, ft as TokenPairQueryConfig, g as revokeDelegationMutationOptions, gn as filterQueryOptions, gr as ZamaError, gt as isConfidentialTokenValidQueryOptions, h as RevokeDelegationParams, hn as StrippedQueryOptionKeys, ht as confidentialTokenAddressQueryOptions, i as decryptValuesQueryOptions, in as invalidateAfterUnshield, it as ConfidentialTransferParams, j as decryptPublicValuesMutationOptions, jr as SerializedTransportKeyPair, jt as ConfidentialIsOperatorQueryConfig, k as preparePermitMutationOptions, kt as BatchDecryptAsOptions, l as BatchDecryptResult, ln as invalidateWagmiBalanceQueries, lt as IsConfidentialTokenValidQueryConfig, m as invalidateDecryptionSignaturesMutationOptions, mn as QueryFactoryOptions, mt as WrappersRegistryQueryConfig, n as DecryptResult, nn as invalidateAfterShield, nt as ConfidentialTransferAndCallParams, o as ZamaSDKOptions, on as invalidateAfterUnwrap, ot as ShieldParams, p as InvalidateDecryptionSignaturesParams, pn as MutationFactoryOptions, pt as TokenPairsSliceQueryConfig, q as unshieldMutationOptions, qt as isWrapperQueryOptions, r as EncryptedInput, rn as invalidateAfterTransfer, rt as confidentialTransferAndCallMutationOptions, s as Offline, sn as invalidateAfterWrap, st as shieldMutationOptions, t as Decryption, tn as invalidateAfterSetOperator, tt as confidentialTransferFromMutationOptions, u as DelegatedDecryptOptions, un as invalidateWalletLifecycleQueries, ut as ListPairsQueryConfig, v as batchDecryptBalancesAsMutationOptions, vn as Delegations, vt as tokenAddressQueryOptions, w as revokePermitsMutationOptions, wr as PreparePermitRequest, wt as confidentialBalancesQueryOptions, x as DelegateDecryptionParams, xt as tokenPairsQueryOptions, y as DecryptBalanceAsParams, yn as DelegationStatus, yt as tokenPairQueryOptions, z as wrapMutationOptions } from "../index-DRrrBtMX.js";
-export { type ApprovalStrategy, type ApproveUnderlyingParams, type ApproveUnderlyingRequest, type ApproveUnderlyingSubmittedEvent, type BaseEvent, type BatchBalancesResult, type BatchDecryptAsOptions, type BatchDecryptBalancesAsParams, type BatchDecryptItem, type BatchDecryptResult, type ChecksummedAddress, type ClearValue, type ConfidentialBalanceQueryConfig, type ConfidentialBalancesQueryConfig, type ConfidentialIsOperatorQueryConfig, type ConfidentialSetOperatorParams, type ConfidentialTokenAddressQueryConfig, type ConfidentialTransferAndCallParams, type ConfidentialTransferEvent, type ConfidentialTransferFromAndCallParams, type ConfidentialTransferFromParams, type ConfidentialTransferFromRequest, type ConfidentialTransferParams, type ConfidentialTransferRequest, type ContractAbi, type DecryptBalanceAsParams, type DecryptEndEvent, type DecryptErrorEvent, type EncryptedInput as DecryptInput, type DecryptPublicValuesResult, type DecryptResult, type DecryptStartEvent, type Decryption, type DelegateDecryptionParams, type DelegateDecryptionRequest, type DelegatedDecryptOptions, type DelegatedDecryptValuesMutationParams, type DelegationStatus, type DelegationStatusQueryConfig, type DelegationSubmittedEvent, type Delegations, type EIP712TypedData, type EncryptEndEvent, type EncryptErrorEvent, type EncryptInput, type EncryptParams, type EncryptResult, type EncryptStartEvent, type EncryptedValue, type FheChain, type FheChainAuth, type FhevmClient, type FhevmRelayerOptions, type FhevmRuntimeConfig, type FinalizeUnwrapParams, type FinalizeUnwrapRequest, type FinalizeUnwrapSubmittedEvent, type GenericLogger, type GenericProvider, type GenericSigner, type GenericStorage, type HasPermitQueryConfig, type InvalidateDecryptionSignaturesParams, type InvalidateDecryptionSignaturesSubmittedEvent, type IsConfidentialQueryConfig, type IsConfidentialTokenValidQueryConfig, type ListPairsOptions, type ListPairsQueryConfig, type MutationFactoryOptions, type Offline, type OnChainEvent, type PaginatedResult, type PendingUnshieldQueryConfig, type PermitErrorEvent, type PermitOperation, type Permits, type PrepareFees, type PrepareOptions, type PreparePermitRequest, type PrepareTransactionRequest, type PreparedFor, type PreparedPermit, type PreparedPermitBase, type PreparedPermitV1, type PreparedPermitV2, type PreparedTransaction, type QueryClientLike, type QueryFactoryOptions, type QueryFilterLike, type QueryLike, type RawLog, type ReadContractArgs, type ReadContractConfig, type ReadContractReturnType, type ReadFunctionName, type RegisterPermitParams, type RelayerSDK, type ResumeUnshieldParams, type RevokeDelegationParams, type RevokeDelegationRequest, type RevokeDelegationSubmittedEvent, type SerializedPermitEip712, type SerializedTransportKeyPair, type SetOperatorRequest, type SetOperatorSubmittedEvent, type ShieldCallbacks, type ShieldOptions, type ShieldParams, type ShieldPath, type ShieldSubmittedEvent, type SignerQueryContext, type StrippedQueryOptionKeys, type Token, type TokenAddressQueryConfig, type TokenMetadata, type TokenMetadataQueryConfig, type TokenPairQueryConfig, type TokenPairsSliceQueryConfig, type TokenWrapperPair, type TokenWrapperPairWithMetadata, type TotalSupplyQueryConfig, type TransactionErrorEvent, type TransactionKind, type TransactionOperation, type TransactionReceipt, type TransactionResult, type TransferAndCallRequest, type TransferCallbacks, type TransferFromSubmittedEvent, type TransferOptions, type TransferSubmittedEvent, type UnderlyingAllowanceQueryConfig, type UnshieldAllParams, type UnshieldCallbacks, type UnshieldOptions, type UnshieldParams, type UnshieldPhase1SubmittedEvent, type UnshieldPhase2StartedEvent, type UnshieldPhase2SubmittedEvent, type UnwrapAllRequest, type UnwrapFinalizedEvent, type UnwrapParams, type UnwrapRequest, type UnwrapRequestedEvent, type UnwrapResult, type UnwrapSubmittedEvent, WILDCARD_PERMIT, type WalletAccount, type WalletAccountChange, type WalletAccountListener, type WalletAccountStore, type WildcardPermit, type WrapEvent, type WrapOptions, type WrapParams, type WrapRequest, type WrapSubmittedEvent, type WrappedToken, type WrapperDiscoveryQueryConfig, type WrappersRegistry, type WrappersRegistryConfig, type WrappersRegistryQueryConfig, type WriteContractArgs, type WriteContractConfig, type WriteFunctionName, type ZamaConfig, type ZamaError, type ZamaErrorCode, type ZamaSDK, type ZamaSDKEvent, type ZamaSDKEventListener, ZamaSDKEvents, type ZamaSDKOptions, approveUnderlyingMutationOptions, batchDecryptBalancesAsMutationOptions, clearCredentialsMutationOptions, confidentialBalanceQueryOptions, confidentialBalancesQueryOptions, confidentialIsOperatorQueryOptions, confidentialSetOperatorMutationOptions, confidentialTokenAddressQueryOptions, confidentialTransferAndCallMutationOptions, confidentialTransferFromAndCallMutationOptions, confidentialTransferFromMutationOptions, confidentialTransferMutationOptions, decryptBalanceAsMutationOptions, decryptPublicValuesMutationOptions, decryptValuesQueryOptions, delegateDecryptionMutationOptions, delegatedDecryptValuesMutationOptions, delegationStatusQueryOptions, encryptMutationOptions, filterQueryOptions, finalizeUnwrapMutationOptions, grantPermitMutationOptions, hasPermitQueryOptions, hashFn, invalidateAfterApproveUnderlying, invalidateAfterSetOperator, invalidateAfterShield, invalidateAfterTransfer, invalidateAfterUnshield, invalidateAfterUnshieldSettled, invalidateAfterUnwrap, invalidateAfterWrap, invalidateBalanceQueries, invalidateDecryptionSignaturesMutationOptions, invalidateWagmiBalanceQueries, invalidateWalletLifecycleQueries, isConfidentialQueryOptions, isConfidentialTokenValidQueryOptions, isWrapperQueryOptions, listPairsQueryOptions, pendingUnshieldQueryOptions, preparePermitMutationOptions, registerPermitMutationOptions, resumeUnshieldMutationOptions, revokeDelegationMutationOptions, revokePermitsMutationOptions, shieldMutationOptions, tokenAddressQueryOptions, tokenMetadataQueryOptions, tokenPairQueryOptions, tokenPairsLengthQueryOptions, tokenPairsQueryOptions, tokenPairsSliceQueryOptions, totalSupplyQueryOptions, underlyingAllowanceQueryOptions, unshieldAllMutationOptions, unshieldMutationOptions, unwrapAllMutationOptions, unwrapMutationOptions, wrapMutationOptions, wrapperDiscoveryQueryOptions, zamaQueryKeys };
+import { f as FheChain, p as FheChainAuth } from "../index-ijgDL4IC.js";
+import { $ as SetOperatorSubmittedEvent, $t as TransactionReceipt, A as WalletAccountListener, B as ApproveUnderlyingSubmittedEvent, C as TransferAndCallRequest, Ct as ShieldCallbacks, D as GenericSigner, E as WrapRequest, F as ReadContractReturnType, Ft as UnwrapFinalizedEvent, G as DelegationSubmittedEvent, H as DecryptEndEvent, I as ReadFunctionName, It as UnwrapRequestedEvent, J as EncryptStartEvent, K as EncryptEndEvent, L as WriteContractArgs, Lt as WrapEvent, M as ContractAbi, N as ReadContractArgs, O as WalletAccount, P as ReadContractConfig, Q as RevokeDelegationSubmittedEvent, Qt as RawLog, R as WriteContractConfig, S as TransactionKind, St as WrapOptions, T as UnwrapRequest, Tt as UnshieldCallbacks, U as DecryptErrorEvent, V as BaseEvent, W as DecryptStartEvent, X as PermitErrorEvent, Y as FinalizeUnwrapSubmittedEvent, Z as PermitOperation, _ as PrepareTransactionRequest, _t as ShieldOptions, an as EncryptInput, at as UnshieldPhase1SubmittedEvent, b as RevokeDelegationRequest, bt as UnshieldOptions, c as GenericStorage, cn as EncryptedValue, ct as UnwrapSubmittedEvent, d as ConfidentialTransferFromRequest, dn as FhevmRelayerOptions, dt as WrapSubmittedEvent, en as TransactionResult, et as ShieldSubmittedEvent, f as ConfidentialTransferRequest, fn as FhevmRuntimeConfig, ft as ZamaSDKEvent, g as PrepareOptions, gt as ApprovalStrategy, h as PrepareFees, ht as ZamaSDKEvents, i as ZamaConfig, in as EIP712TypedData, it as TransferSubmittedEvent, j as WalletAccountStore, jt as OnChainEvent, k as WalletAccountChange, kt as ConfidentialTransferEvent, l as GenericProvider, ln as FhevmClient, m as FinalizeUnwrapRequest, mn as RelayerSDK, nn as DecryptPublicValuesResult, nt as TransactionOperation, on as EncryptParams, ot as UnshieldPhase2StartedEvent, p as DelegateDecryptionRequest, pt as ZamaSDKEventListener, q as EncryptErrorEvent, rt as TransferFromSubmittedEvent, s as GenericLogger, sn as EncryptResult, st as UnshieldPhase2SubmittedEvent, tn as ClearValue, tt as TransactionErrorEvent, u as ApproveUnderlyingRequest, v as PreparedFor, vt as ShieldPath, w as UnwrapAllRequest, wt as TransferCallbacks, x as SetOperatorRequest, xt as UnwrapResult, y as PreparedTransaction, yt as TransferOptions, z as WriteFunctionName } from "../types-Bz5-wHPv.js";
+import { A as BatchDecryptAsOptions, C as ZamaSDKOptions, D as WrappersRegistryConfig, Dt as ZamaErrorCode, E as WrappersRegistry, Et as ZamaError, F as Permits, Ft as SerializedTransportKeyPair, It as ChecksummedAddress, Lt as PaginatedResult, M as Offline, Mt as PreparedPermit, N as Delegations, O as WrappedToken, P as DelegationStatus, Pt as SerializedPermitEip712, Rt as TokenWrapperPair, S as ZamaSDK, T as ListPairsOptions, _ as decryptValuesQueryOptions, b as MutationFactoryOptions, d as Decryption, f as BatchDecryptItem, g as EncryptedInput, h as DecryptResult, j as Token, jt as PreparePermitRequest, k as BatchBalancesResult, m as DelegatedDecryptOptions, p as BatchDecryptResult, v as SignerQueryContext, x as QueryFactoryOptions, y as zamaQueryKeys, zt as TokenWrapperPairWithMetadata } from "../index-DJYq1rAB.js";
+import "../index-BHrjck_q.js";
+import { a as invalidateAfterSetOperator, c as invalidateAfterUnshield, d as invalidateAfterWrap, f as invalidateBalanceQueries, i as invalidateAfterApproveUnderlying, l as invalidateAfterUnshieldSettled, m as invalidateWalletLifecycleQueries, n as QueryFilterLike, o as invalidateAfterShield, p as invalidateWagmiBalanceQueries, r as QueryLike, s as invalidateAfterTransfer, t as QueryClientLike, u as invalidateAfterUnwrap } from "../invalidation-CJ-pzOUG.js";
+import { Address, Hex } from "viem";
+//#region src/query/utils.d.ts
+/** Union of TanStack Query option keys stripped by {@link filterQueryOptions}, leaving only domain parameters. */
+type StrippedQueryOptionKeys = "gcTime" | "staleTime" | "enabled" | "select" | "refetchInterval" | "refetchOnMount" | "refetchOnWindowFocus" | "refetchOnReconnect" | "retry" | "retryDelay" | "retryOnMount" | "queryFn" | "queryKey" | "queryKeyHashFn" | "initialData" | "initialDataUpdatedAt" | "placeholderData" | "structuralSharing" | "throwOnError" | "meta" | "query" | "pollingInterval";
+/**
+ * Remove TanStack behavioral options from a query config object so only domain
+ * parameters remain for the lower-level factory.
+ *
+ * @example
+ * ```ts
+ * const params = filterQueryOptions({
+ *   query: { enabled: false },
+ *   gcTime: 60_000,
+ *   owner: "0xabc",
+ * });
+ * // => { owner: "0xabc" }
+ * ```
+ */
+declare function filterQueryOptions<TOptions extends Record<string, unknown>>(options: TOptions): Omit<TOptions, StrippedQueryOptionKeys>;
+/**
+ * Stable hash function for query keys.
+ * Sorts object keys recursively and converts bigint values to strings.
+ *
+ * @remarks
+ * bigint values are serialized as decimal strings, so `42n` and `"42"` hash to
+ * the same token when they occupy the same position. This collision is accepted
+ * by design for the current query-key conventions in this package.
+ */
+declare function hashFn(queryKey: readonly unknown[]): string;
+//#endregion
+//#region src/query/token-metadata.d.ts
+/** ERC-20 token metadata returned by {@link tokenMetadataQueryOptions}. */
+interface TokenMetadata {
+  /** Human-readable token name. */
+  name: string;
+  /** Token ticker symbol. */
+  symbol: string;
+  /** Number of decimals the token uses. */
+  decimals: number;
+}
+/** Configuration for {@link tokenMetadataQueryOptions}. */
+interface TokenMetadataQueryConfig {
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
+  query?: Record<string, unknown>;
+}
+/** Builds TanStack Query options for reading an ERC-20 token's name, symbol, and decimals. */
+declare function tokenMetadataQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config?: TokenMetadataQueryConfig): QueryFactoryOptions<TokenMetadata, Error, TokenMetadata, ReturnType<typeof zamaQueryKeys.tokenMetadata.token>>;
+//#endregion
+//#region src/query/is-confidential.d.ts
+/** Configuration for {@link isConfidentialQueryOptions} and {@link isWrapperQueryOptions}. */
+interface IsConfidentialQueryConfig {
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
+  query?: Record<string, unknown>;
+}
+/** Builds TanStack Query options for reading whether a token address implements the confidential (ERC-7984) token interface. */
+declare function isConfidentialQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config?: IsConfidentialQueryConfig): QueryFactoryOptions<boolean, Error, boolean, ReturnType<typeof zamaQueryKeys.isConfidential.token>>;
+/** Builds TanStack Query options for reading whether a token address is a confidential wrapper (ERC-7984 wrapper) contract. */
+declare function isWrapperQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config?: IsConfidentialQueryConfig): QueryFactoryOptions<boolean, Error, boolean, ReturnType<typeof zamaQueryKeys.isWrapper.token>>;
+//#endregion
+//#region src/query/total-supply.d.ts
+/** Configuration for {@link totalSupplyQueryOptions}. */
+interface TotalSupplyQueryConfig {
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
+  query?: Record<string, unknown>;
+}
+/** Builds TanStack Query options for reading a token's total supply. */
+declare function totalSupplyQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config?: TotalSupplyQueryConfig): QueryFactoryOptions<bigint, Error, bigint, ReturnType<typeof zamaQueryKeys.totalSupply.token>>;
+//#endregion
+//#region src/query/wrapper-discovery.d.ts
+/** Configuration for {@link wrapperDiscoveryQueryOptions}. */
+interface WrapperDiscoveryQueryConfig {
+  /**
+   * Address of any confidential token you control.
+   * Used to scope the query cache key and to gate whether the query
+   * is enabled — it does not affect which wrapper the registry returns.
+   */
+  tokenAddress?: Address;
+  /**
+   * The ERC-20 token address to discover the confidential wrapper for.
+   * The registry is resolved automatically from chain config.
+   */
+  erc20Address?: Address;
+  /**
+   * The resolved registry contract address for the current chain.
+   * Included in the query key so that switching chains invalidates
+   * stale cached results. Pass `undefined` when the chain ID is not
+   * yet known — the query will be disabled.
+   */
+  registryAddress?: Address;
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
+  query?: Record<string, unknown>;
+}
+/** Builds TanStack Query options for discovering the confidential wrapper address for a given ERC-20 token (resolves to `null` when none is registered). */
+declare function wrapperDiscoveryQueryOptions(registry: WrappersRegistry, config: WrapperDiscoveryQueryConfig): QueryFactoryOptions<Address | null, Error, Address | null, ReturnType<typeof zamaQueryKeys.wrapperDiscovery.token>>;
+//#endregion
+//#region src/query/underlying-allowance.d.ts
+/** Configuration for {@link underlyingAllowanceQueryOptions}. */
+interface UnderlyingAllowanceQueryConfig {
+  /** Owner whose underlying-token allowance to read; the query stays disabled until provided. */
+  owner?: Address;
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
+  query?: Record<string, unknown>;
+}
+/** Builds TanStack Query options for reading the ERC-20 allowance the owner has granted a confidential wrapper on its underlying token. */
+declare function underlyingAllowanceQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config: UnderlyingAllowanceQueryConfig): QueryFactoryOptions<bigint, Error, bigint, ReturnType<typeof zamaQueryKeys.underlyingAllowance.scope>>;
+//#endregion
+//#region src/query/pending-unshield.d.ts
+/** Configuration for {@link pendingUnshieldQueryOptions}. */
+interface PendingUnshieldQueryConfig {
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
+  query?: Record<string, unknown>;
+}
+/**
+ * Query options for reading the unwrap tx hash of an unshield that was
+ * interrupted between its two phases (returns `null` if none is pending).
+ *
+ * Backed by {@link ZamaSDK} storage via `WrappedToken.getPendingUnshield()`.
+ * `staleTime: 0` so the value reflects storage on mount; the unshield/unwrap
+ * mutations also invalidate this key on success.
+ */
+declare function pendingUnshieldQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config?: PendingUnshieldQueryConfig): QueryFactoryOptions<Hex | null, Error, Hex | null, ReturnType<typeof zamaQueryKeys.pendingUnshield.token>>;
+//#endregion
+//#region src/query/confidential-is-operator.d.ts
+/** Configuration for {@link confidentialIsOperatorQueryOptions}. */
+interface ConfidentialIsOperatorQueryConfig {
+  /** Token holder whose operator authorization to check; the query stays disabled until provided. */
+  holder?: Address;
+  /** Spender address to check for operator authorization; the query stays disabled until provided. */
+  spender?: Address;
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
+  query?: Record<string, unknown>;
+}
+/** Builds TanStack Query options for reading whether a spender is an authorized operator of a holder on a confidential token. */
+declare function confidentialIsOperatorQueryOptions(sdk: ZamaSDK, tokenAddress: Address | undefined, config: ConfidentialIsOperatorQueryConfig): QueryFactoryOptions<boolean, Error, boolean, ReturnType<typeof zamaQueryKeys.confidentialIsOperator.scope>>;
+//#endregion
+//#region src/query/confidential-balance.d.ts
+/** Configuration for {@link confidentialBalanceQueryOptions}. */
+interface ConfidentialBalanceQueryConfig {
+  /** Address of the confidential token to read the balance of. */
+  tokenAddress: Address;
+  /** Account whose confidential balance to read; the query stays disabled until provided. */
+  account?: Address;
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
+  query?: Record<string, unknown>;
+}
+/** Query options for a single confidential token balance. Auto-gated on `account`. */
+declare function confidentialBalanceQueryOptions(token: Token, config: ConfidentialBalanceQueryConfig, signerContext?: SignerQueryContext): QueryFactoryOptions<bigint, Error, bigint, ReturnType<typeof zamaQueryKeys.confidentialBalance.owner>>;
+//#endregion
+//#region src/query/confidential-balances.d.ts
+/** Configuration for {@link confidentialBalancesQueryOptions}. */
+interface ConfidentialBalancesQueryConfig {
+  /** Account whose confidential balances to read; the query stays disabled until provided. */
+  account?: Address;
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
+  query?: Record<string, unknown>;
+}
+/** Builds TanStack Query options for reading the confidential balances of several tokens for one account in a single batch. */
+declare function confidentialBalancesQueryOptions(tokens: Token[], config?: ConfidentialBalancesQueryConfig, signerContext?: SignerQueryContext): QueryFactoryOptions<BatchBalancesResult, Error, BatchBalancesResult, ReturnType<typeof zamaQueryKeys.confidentialBalances.tokens>>;
+//#endregion
+//#region src/query/wrappers-registry.d.ts
+/** Base configuration shared by the wrappers-registry query option factories. */
+interface WrappersRegistryQueryConfig {
+  /** Registry contract address for the current chain; used as a query key discriminator. */
+  registryAddress: Address | undefined;
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
+  query?: Record<string, unknown>;
+}
+/** Builds TanStack Query options for reading all token wrapper pairs registered in the wrappers registry. */
+declare function tokenPairsQueryOptions(sdk: ZamaSDK, config: WrappersRegistryQueryConfig): QueryFactoryOptions<readonly TokenWrapperPair[], Error, readonly TokenWrapperPair[], ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenPairs>>;
+/** Configuration for {@link confidentialTokenAddressQueryOptions}. */
+interface ConfidentialTokenAddressQueryConfig extends WrappersRegistryQueryConfig {
+  /** Underlying ERC-20 token address whose confidential counterpart to look up. */
+  tokenAddress?: Address;
+}
+/** Builds TanStack Query options for reading the confidential token address registered for a given underlying ERC-20 token. */
+declare function confidentialTokenAddressQueryOptions(sdk: ZamaSDK, config: ConfidentialTokenAddressQueryConfig): QueryFactoryOptions<readonly [boolean, Address], Error, readonly [boolean, Address], ReturnType<typeof zamaQueryKeys.wrappersRegistry.confidentialTokenAddress>>;
+/** Configuration for {@link tokenAddressQueryOptions}. */
+interface TokenAddressQueryConfig extends WrappersRegistryQueryConfig {
+  /** Confidential token address whose underlying ERC-20 counterpart to look up. */
+  confidentialTokenAddress?: Address;
+}
+/** Builds TanStack Query options for reading the underlying ERC-20 token address registered for a given confidential token. */
+declare function tokenAddressQueryOptions(sdk: ZamaSDK, config: TokenAddressQueryConfig): QueryFactoryOptions<readonly [boolean, Address], Error, readonly [boolean, Address], ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenAddress>>;
+/** Builds TanStack Query options for reading the total number of token wrapper pairs in the registry. */
+declare function tokenPairsLengthQueryOptions(sdk: ZamaSDK, config: WrappersRegistryQueryConfig): QueryFactoryOptions<bigint, Error, bigint, ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenPairsLength>>;
+/** Configuration for {@link tokenPairsSliceQueryOptions}. */
+interface TokenPairsSliceQueryConfig extends WrappersRegistryQueryConfig {
+  /** Zero-based index of the first pair in the slice (inclusive). */
+  fromIndex?: bigint;
+  /** Index bounding the end of the slice. */
+  toIndex?: bigint;
+}
+/** Builds TanStack Query options for reading a contiguous slice of the registry's token wrapper pairs. */
+declare function tokenPairsSliceQueryOptions(sdk: ZamaSDK, config: TokenPairsSliceQueryConfig): QueryFactoryOptions<readonly TokenWrapperPair[], Error, readonly TokenWrapperPair[], ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenPairsSlice>>;
+/** Configuration for {@link tokenPairQueryOptions}. */
+interface TokenPairQueryConfig extends WrappersRegistryQueryConfig {
+  /** Zero-based index of the token wrapper pair to read. */
+  index?: bigint;
+}
+/** Builds TanStack Query options for reading a single token wrapper pair by its index in the registry. */
+declare function tokenPairQueryOptions(sdk: ZamaSDK, config: TokenPairQueryConfig): QueryFactoryOptions<TokenWrapperPair, Error, TokenWrapperPair, ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenPair>>;
+/** Configuration for {@link isConfidentialTokenValidQueryOptions}. */
+interface IsConfidentialTokenValidQueryConfig extends WrappersRegistryQueryConfig {
+  /** Confidential token address to validate against the registry. */
+  confidentialTokenAddress?: Address;
+}
+/** Builds TanStack Query options for checking whether a confidential token is registered and valid in the registry. */
+declare function isConfidentialTokenValidQueryOptions(sdk: ZamaSDK, config: IsConfidentialTokenValidQueryConfig): QueryFactoryOptions<boolean, Error, boolean, ReturnType<typeof zamaQueryKeys.wrappersRegistry.isConfidentialTokenValid>>;
+/** Configuration for {@link listPairsQueryOptions}. */
+interface ListPairsQueryConfig {
+  /**
+   * The registry address for this chain — used as a query key discriminator.
+   * The registry instance already knows how to resolve the address for the
+   * current chain; this field just keeps the TanStack Query cache isolated
+   * per registry contract.
+   */
+  registryAddress: Address | undefined;
+  /** 1-based page number to fetch; defaults to `1`. */
+  page?: number;
+  /** Number of pairs per page; defaults to `100`. */
+  pageSize?: number;
+  /** When `true`, resolve each pair's on-chain metadata; defaults to `false`. */
+  metadata?: boolean;
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
+  query?: Record<string, unknown>;
+}
+/**
+ * Query options for paginated listing of token wrapper pairs.
+ *
+ * Accepts a {@link WrappersRegistry} instance rather than a raw provider so that the
+ * class-level TTL cache is shared across multiple `queryFn` executions. Pass
+ * `sdk.registry` (the ZamaSDK lazy singleton) to ensure a single shared cache.
+ */
+declare function listPairsQueryOptions(registry: WrappersRegistry, config: ListPairsQueryConfig): QueryFactoryOptions<PaginatedResult<TokenWrapperPair | TokenWrapperPairWithMetadata>, Error, PaginatedResult<TokenWrapperPair | TokenWrapperPairWithMetadata>, ReturnType<typeof zamaQueryKeys.wrappersRegistry.listPairs>>;
+//#endregion
+//#region src/query/shield.d.ts
+/** Variables for {@link shieldMutationOptions}. */
+interface ShieldParams extends ShieldOptions {
+  /** Amount of the public ERC-20 to shield, in the token's base units. */
+  amount: bigint;
+}
+/** Builds TanStack Query mutation options for {@link WrappedToken.shield | shielding} a public ERC-20 into its confidential form. @see {@link ShieldParams} */
+declare function shieldMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.shield", Address], ShieldParams, TransactionResult>;
+//#endregion
+//#region src/query/transfer.d.ts
+/** Variables for {@link confidentialTransferMutationOptions}. */
+interface ConfidentialTransferParams extends TransferOptions {
+  /** Recipient address. */
+  to: Address;
+  /** Amount of tokens to transfer, in the token's base units. */
+  amount: bigint;
+}
+/** Builds TanStack Query mutation options for {@link Token.confidentialTransfer | transferring} confidential tokens. @see {@link ConfidentialTransferParams} */
+declare function confidentialTransferMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.confidentialTransfer", Address], ConfidentialTransferParams, TransactionResult>;
+//#endregion
+//#region src/query/transfer-and-call.d.ts
+/** Variables for {@link confidentialTransferAndCallMutationOptions}. */
+interface ConfidentialTransferAndCallParams extends TransferOptions {
+  /** Recipient address. */
+  to: Address;
+  /** Amount of tokens to transfer, in the token's base units. */
+  amount: bigint;
+  /** Opaque bytes forwarded to the recipient's ERC-7984 receiver hook. */
+  data: Hex;
+}
+/** Builds TanStack Query mutation options for {@link Token.confidentialTransferAndCall | transferring} confidential tokens and invoking the recipient's receiver hook. @see {@link ConfidentialTransferAndCallParams} */
+declare function confidentialTransferAndCallMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.confidentialTransferAndCall", Address], ConfidentialTransferAndCallParams, TransactionResult>;
+//#endregion
+//#region src/query/transfer-from.d.ts
+/** Variables for {@link confidentialTransferFromMutationOptions}. */
+interface ConfidentialTransferFromParams {
+  /** Address to transfer from. */
+  from: Address;
+  /** Recipient address. */
+  to: Address;
+  /** Amount of tokens to transfer, in the token's base units. */
+  amount: bigint;
+  /** Optional progress callbacks for the multi-step transfer flow. */
+  callbacks?: TransferCallbacks;
+}
+/** Builds TanStack Query mutation options for {@link Token.confidentialTransferFrom | transferring} confidential tokens from another account (operator flow). @see {@link ConfidentialTransferFromParams} */
+declare function confidentialTransferFromMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.confidentialTransferFrom", Address], ConfidentialTransferFromParams, TransactionResult>;
+//#endregion
+//#region src/query/transfer-from-and-call.d.ts
+/** Variables for {@link confidentialTransferFromAndCallMutationOptions}. */
+interface ConfidentialTransferFromAndCallParams {
+  /** Address to transfer from. */
+  from: Address;
+  /** Recipient address. */
+  to: Address;
+  /** Amount of tokens to transfer, in the token's base units. */
+  amount: bigint;
+  /** Opaque bytes forwarded to the recipient's ERC-7984 receiver hook. */
+  data: Hex;
+  /** Optional progress callbacks for the multi-step transfer flow. */
+  callbacks?: TransferCallbacks;
+}
+/** Builds TanStack Query mutation options for {@link Token.confidentialTransferFromAndCall | transferring} confidential tokens from another account and invoking the recipient's receiver hook. @see {@link ConfidentialTransferFromAndCallParams} */
+declare function confidentialTransferFromAndCallMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.confidentialTransferFromAndCall", Address], ConfidentialTransferFromAndCallParams, TransactionResult>;
+//#endregion
+//#region src/query/set-operator.d.ts
+/** Variables for {@link confidentialSetOperatorMutationOptions}. */
+interface ConfidentialSetOperatorParams {
+  /** Operator address to authorize. */
+  operator: Address;
+  /** Unix timestamp (seconds) when the operator authorization expires; defaults to one hour from now. */
+  until?: number;
+}
+/** Builds TanStack Query mutation options for {@link Token.setOperator | authorizing} an operator on a confidential token. @see {@link ConfidentialSetOperatorParams} */
+declare function confidentialSetOperatorMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.confidentialSetOperator", Address], ConfidentialSetOperatorParams, TransactionResult>;
+//#endregion
+//#region src/query/approve-underlying.d.ts
+/** Variables for {@link approveUnderlyingMutationOptions}. */
+interface ApproveUnderlyingParams {
+  /** Amount of the underlying ERC-20 to approve, in its base units; omit for a max approval. */
+  amount?: bigint;
+}
+/** Builds TanStack Query mutation options for {@link WrappedToken.approveUnderlying | approving} the wrapper to spend the underlying ERC-20. @see {@link ApproveUnderlyingParams} */
+declare function approveUnderlyingMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.approveUnderlying", Address], ApproveUnderlyingParams, TransactionResult>;
+//#endregion
+//#region src/query/unshield.d.ts
+/** Variables for {@link unshieldMutationOptions}. */
+interface UnshieldParams extends UnshieldOptions {
+  /** Amount of tokens to unshield, in the token's base units. */
+  amount: bigint;
+}
+/** Builds TanStack Query mutation options for {@link WrappedToken.unshield | unshielding} a confidential token back into its public ERC-20. @see {@link UnshieldParams} */
+declare function unshieldMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.unshield", Address], UnshieldParams, TransactionResult>;
+//#endregion
+//#region src/query/unshield-all.d.ts
+/** Variables for {@link unshieldAllMutationOptions}. */
+interface UnshieldAllParams extends UnshieldCallbacks {}
+/** Builds TanStack Query mutation options for {@link WrappedToken.unshieldAll | unshielding} the entire confidential balance back into the public ERC-20. @see {@link UnshieldAllParams} */
+declare function unshieldAllMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.unshieldAll", Address], UnshieldAllParams | void, TransactionResult>;
+//#endregion
+//#region src/query/resume-unshield.d.ts
+/** Variables for {@link resumeUnshieldMutationOptions}. */
+interface ResumeUnshieldParams extends UnshieldCallbacks {
+  /** Hash of the earlier unwrap request transaction to resume from. */
+  unwrapTxHash: Hex;
+}
+/** Builds TanStack Query mutation options for {@link WrappedToken.resumeUnshield | resuming} an interrupted unshield from its unwrap request transaction. @see {@link ResumeUnshieldParams} */
+declare function resumeUnshieldMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.resumeUnshield", Address], ResumeUnshieldParams, TransactionResult>;
+//#endregion
+//#region src/query/unwrap.d.ts
+/** Variables for {@link unwrapMutationOptions}. */
+interface UnwrapParams {
+  /** Amount of tokens to unwrap, in the token's base units. */
+  amount: bigint;
+}
+/** Builds TanStack Query mutation options for {@link WrappedToken.unwrap | unwrapping} a confidential token (request phase of the two-phase unwrap). @see {@link UnwrapParams} */
+declare function unwrapMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.unwrap", Address], UnwrapParams, UnwrapResult>;
+//#endregion
+//#region src/query/wrap.d.ts
+/** Variables for {@link wrapMutationOptions}. */
+interface WrapParams extends WrapOptions {
+  /** Amount of the public ERC-20 to wrap, in the token's base units. */
+  amount: bigint;
+}
+/** Builds TanStack Query mutation options for {@link WrappedToken.wrap | wrapping} a public ERC-20 into its confidential form. @see {@link WrapParams} */
+declare function wrapMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.wrap", Address], WrapParams, TransactionResult>;
+//#endregion
+//#region src/query/unwrap-all.d.ts
+/** Builds TanStack Query mutation options for {@link WrappedToken.unwrapAll | unwrapping} the entire confidential balance. */
+declare function unwrapAllMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.unwrapAll", Address], void, UnwrapResult>;
+//#endregion
+//#region src/query/finalize-unwrap.d.ts
+/** Variables for {@link finalizeUnwrapMutationOptions}. */
+type FinalizeUnwrapParams = {
+  /** Identifier from an `UnwrapRequested` event. */
+  unwrapRequestId: EncryptedValue;
+};
+/** Builds TanStack Query mutation options for {@link WrappedToken.finalizeUnwrap | finalizing} a previously requested unwrap. @see {@link FinalizeUnwrapParams} */
+declare function finalizeUnwrapMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.finalizeUnwrap", Address], FinalizeUnwrapParams, TransactionResult>;
+//#endregion
+//#region src/query/encrypt.d.ts
+/** Builds TanStack Query mutation options for {@link ZamaSDK.encrypt | encrypting} plaintext inputs into an encrypted payload. */
+declare function encryptMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.encrypt"], EncryptParams, EncryptResult>;
+//#endregion
+//#region src/query/delegated-decrypt.d.ts
+/** Variables for {@link delegatedDecryptValuesMutationOptions}. */
+interface DelegatedDecryptValuesMutationParams {
+  /** Encrypted values (with their contract addresses) to decrypt. */
+  encryptedInputs: EncryptedInput[];
+  /** Address of the account that delegated decryption rights to the connected wallet. */
+  delegatorAddress: Address;
+}
+/** Builds TanStack Query mutation options for {@link Decryption.delegatedDecryptValues | decrypting} encrypted values via delegated decryption credentials. @see {@link DelegatedDecryptValuesMutationParams} */
+declare function delegatedDecryptValuesMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.delegatedDecryptValues"], DelegatedDecryptValuesMutationParams, Readonly<Record<EncryptedValue, ClearValue>>>;
+//#endregion
+//#region src/query/public-decrypt.d.ts
+/** Builds TanStack Query mutation options for {@link Decryption.decryptPublicValues | publicly decrypting} encrypted values, caching each clear result. */
+declare function decryptPublicValuesMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.decryptPublicValues"], EncryptedValue[], DecryptPublicValuesResult>;
+//#endregion
+//#region src/query/grant-permit.d.ts
+/** Builds TanStack Query mutation options for {@link Permits.grantPermit | granting} decryption permits for the given contract addresses. */
+declare function grantPermitMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.grantPermit"], Address[], void>;
+//#endregion
+//#region src/query/prepare-permit.d.ts
+/** Builds TanStack Query mutation options for {@link Offline.preparePermit | preparing} an offline decryption permit. */
+declare function preparePermitMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.preparePermit"], PreparePermitRequest, PreparedPermit>;
+//#endregion
+//#region src/query/register-permit.d.ts
+/** Parameters for {@link registerPermitMutationOptions}. */
+interface RegisterPermitParams {
+  /** The payload `sdk.offline.preparePermit` returned. */
+  prepared: PreparedPermit;
+  /** The `eth_signTypedData_v4` signature over `prepared.eip712`. */
+  signature: Hex;
+}
+/** Builds TanStack Query mutation options for {@link Permits.registerPermit | registering} a signed offline permit. */
+declare function registerPermitMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.registerPermit"], RegisterPermitParams, void>;
+//#endregion
+//#region src/query/has-permit.d.ts
+/** Configuration for {@link hasPermitQueryOptions}. */
+interface HasPermitQueryConfig {
+  /** Contract addresses to check credentials against. */
+  contractAddresses: Address[];
+  /**
+   * Standard TanStack query options. `hasPermit` intentionally overrides cache
+   * timing because permit state is wallet-local, not server state: every fetch
+   * should read the SDK credential service directly.
+   */
+  query?: Record<string, unknown>;
+}
+/** Builds TanStack Query options for reading whether the connected wallet holds a valid decryption permit for the given contracts. */
+declare function hasPermitQueryOptions(sdk: ZamaSDK, config: HasPermitQueryConfig, signerContext?: SignerQueryContext): QueryFactoryOptions<boolean, Error, boolean, ReturnType<typeof zamaQueryKeys.hasPermit.scope>>;
+//#endregion
+//#region src/query/revoke-permits.d.ts
+/** TanStack Query mutation factory for {@link Permits.revokePermits}. */
+declare function revokePermitsMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.revokePermits"], Address[] | void, void>;
+//#endregion
+//#region src/query/clear-credentials.d.ts
+/** TanStack Query mutation factory for {@link Permits.clear}. */
+declare function clearCredentialsMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.clearCredentials"], void, void>;
+//#endregion
+//#region src/query/delegate-decryption.d.ts
+/** Variables for {@link delegateDecryptionMutationOptions}. */
+interface DelegateDecryptionParams {
+  /** Address to grant delegated decryption rights to. */
+  delegateAddress: Address;
+  /** When the delegation expires; omit for no expiry. */
+  expirationDate?: Date;
+}
+/** Builds TanStack Query mutation options for {@link Delegations.delegateDecryption | granting} delegated decryption rights on a contract. @see {@link DelegateDecryptionParams} */
+declare function delegateDecryptionMutationOptions(sdk: ZamaSDK, contractAddress: Address): MutationFactoryOptions<readonly ["zama.delegateDecryption", Address], DelegateDecryptionParams, TransactionResult>;
+//#endregion
+//#region src/query/decrypt-balance-as.d.ts
+/** Variables for {@link decryptBalanceAsMutationOptions}. */
+interface DecryptBalanceAsParams {
+  /** Address of the account that delegated decryption rights to the connected wallet. */
+  delegatorAddress: Address;
+  /** Account whose on-chain balance to read; defaults to the delegator address. */
+  accountAddress?: Address;
+}
+/** Builds TanStack Query mutation options for {@link Token.decryptBalanceAs | decrypting} a balance via delegated decryption credentials. @see {@link DecryptBalanceAsParams} */
+declare function decryptBalanceAsMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.decryptBalanceAs", Address], DecryptBalanceAsParams, bigint>;
+//#endregion
+//#region src/query/batch-decrypt-balances-as.d.ts
+/** Variables for {@link batchDecryptBalancesAsMutationOptions}. */
+type BatchDecryptBalancesAsParams = BatchDecryptAsOptions;
+/** Builds TanStack Query mutation options for {@link Token.batchDecryptBalancesAs | decrypting} multiple token balances via delegated decryption credentials. @see {@link BatchDecryptBalancesAsParams} */
+declare function batchDecryptBalancesAsMutationOptions(tokens: Token[]): MutationFactoryOptions<readonly ["zama.batchDecryptBalancesAs", ...Address[]], BatchDecryptBalancesAsParams, Map<Address, bigint>>;
+//#endregion
+//#region src/query/revoke-delegation.d.ts
+/** Variables for {@link revokeDelegationMutationOptions}. */
+interface RevokeDelegationParams {
+  /** Address whose delegated decryption rights to revoke. */
+  delegateAddress: Address;
+}
+/** Builds TanStack Query mutation options for {@link Delegations.revokeDelegation | revoking} delegated decryption rights on a contract. @see {@link RevokeDelegationParams} */
+declare function revokeDelegationMutationOptions(sdk: ZamaSDK, contractAddress: Address): MutationFactoryOptions<readonly ["zama.revokeDelegation", Address], RevokeDelegationParams, TransactionResult>;
+//#endregion
+//#region src/query/delegation-status.d.ts
+/** Configuration for {@link delegationStatusQueryOptions}. */
+interface DelegationStatusQueryConfig {
+  /** Contract the delegation applies to; pass `undefined` to keep the query disabled. */
+  contractAddress: Address | undefined;
+  /** Address granting the delegated decryption rights; the query stays disabled until provided. */
+  delegatorAddress?: Address;
+  /** Address receiving the delegated decryption rights; the query stays disabled until provided. */
+  delegateAddress?: Address;
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
+  query?: Record<string, unknown>;
+}
+/** Builds TanStack Query options for reading the decryption-delegation status between a delegator and a delegate on a contract. */
+declare function delegationStatusQueryOptions(sdk: ZamaSDK, config: DelegationStatusQueryConfig): QueryFactoryOptions<DelegationStatus, Error, DelegationStatus, ReturnType<typeof zamaQueryKeys.delegationStatus.scope>>;
+//#endregion
+export { type ApprovalStrategy, type ApproveUnderlyingParams, type ApproveUnderlyingRequest, type ApproveUnderlyingSubmittedEvent, type BaseEvent, type BatchBalancesResult, type BatchDecryptAsOptions, type BatchDecryptBalancesAsParams, type BatchDecryptItem, type BatchDecryptResult, type ChecksummedAddress, type ClearValue, type ConfidentialBalanceQueryConfig, type ConfidentialBalancesQueryConfig, type ConfidentialIsOperatorQueryConfig, type ConfidentialSetOperatorParams, type ConfidentialTokenAddressQueryConfig, type ConfidentialTransferAndCallParams, type ConfidentialTransferEvent, type ConfidentialTransferFromAndCallParams, type ConfidentialTransferFromParams, type ConfidentialTransferFromRequest, type ConfidentialTransferParams, type ConfidentialTransferRequest, type ContractAbi, type DecryptBalanceAsParams, type DecryptEndEvent, type DecryptErrorEvent, type EncryptedInput as DecryptInput, type DecryptPublicValuesResult, type DecryptResult, type DecryptStartEvent, type Decryption, type DelegateDecryptionParams, type DelegateDecryptionRequest, type DelegatedDecryptOptions, type DelegatedDecryptValuesMutationParams, type DelegationStatus, type DelegationStatusQueryConfig, type DelegationSubmittedEvent, type Delegations, type EIP712TypedData, type EncryptEndEvent, type EncryptErrorEvent, type EncryptInput, type EncryptParams, type EncryptResult, type EncryptStartEvent, type EncryptedValue, type FheChain, type FheChainAuth, type FhevmClient, type FhevmRelayerOptions, type FhevmRuntimeConfig, type FinalizeUnwrapParams, type FinalizeUnwrapRequest, type FinalizeUnwrapSubmittedEvent, type GenericLogger, type GenericProvider, type GenericSigner, type GenericStorage, type HasPermitQueryConfig, type IsConfidentialQueryConfig, type IsConfidentialTokenValidQueryConfig, type ListPairsOptions, type ListPairsQueryConfig, type MutationFactoryOptions, type Offline, type OnChainEvent, type PaginatedResult, type PendingUnshieldQueryConfig, type PermitErrorEvent, type PermitOperation, type Permits, type PrepareFees, type PrepareOptions, type PreparePermitRequest, type PrepareTransactionRequest, type PreparedFor, type PreparedPermit, type PreparedTransaction, type QueryClientLike, type QueryFactoryOptions, type QueryFilterLike, type QueryLike, type RawLog, type ReadContractArgs, type ReadContractConfig, type ReadContractReturnType, type ReadFunctionName, type RegisterPermitParams, type RelayerSDK, type ResumeUnshieldParams, type RevokeDelegationParams, type RevokeDelegationRequest, type RevokeDelegationSubmittedEvent, type SerializedPermitEip712, type SerializedTransportKeyPair, type SetOperatorRequest, type SetOperatorSubmittedEvent, type ShieldCallbacks, type ShieldOptions, type ShieldParams, type ShieldPath, type ShieldSubmittedEvent, type SignerQueryContext, type StrippedQueryOptionKeys, type Token, type TokenAddressQueryConfig, type TokenMetadata, type TokenMetadataQueryConfig, type TokenPairQueryConfig, type TokenPairsSliceQueryConfig, type TokenWrapperPair, type TokenWrapperPairWithMetadata, type TotalSupplyQueryConfig, type TransactionErrorEvent, type TransactionKind, type TransactionOperation, type TransactionReceipt, type TransactionResult, type TransferAndCallRequest, type TransferCallbacks, type TransferFromSubmittedEvent, type TransferOptions, type TransferSubmittedEvent, type UnderlyingAllowanceQueryConfig, type UnshieldAllParams, type UnshieldCallbacks, type UnshieldOptions, type UnshieldParams, type UnshieldPhase1SubmittedEvent, type UnshieldPhase2StartedEvent, type UnshieldPhase2SubmittedEvent, type UnwrapAllRequest, type UnwrapFinalizedEvent, type UnwrapParams, type UnwrapRequest, type UnwrapRequestedEvent, type UnwrapResult, type UnwrapSubmittedEvent, type WalletAccount, type WalletAccountChange, type WalletAccountListener, type WalletAccountStore, type WrapEvent, type WrapOptions, type WrapParams, type WrapRequest, type WrapSubmittedEvent, type WrappedToken, type WrapperDiscoveryQueryConfig, type WrappersRegistry, type WrappersRegistryConfig, type WrappersRegistryQueryConfig, type WriteContractArgs, type WriteContractConfig, type WriteFunctionName, type ZamaConfig, type ZamaError, type ZamaErrorCode, type ZamaSDK, type ZamaSDKEvent, type ZamaSDKEventListener, ZamaSDKEvents, type ZamaSDKOptions, approveUnderlyingMutationOptions, batchDecryptBalancesAsMutationOptions, clearCredentialsMutationOptions, confidentialBalanceQueryOptions, confidentialBalancesQueryOptions, confidentialIsOperatorQueryOptions, confidentialSetOperatorMutationOptions, confidentialTokenAddressQueryOptions, confidentialTransferAndCallMutationOptions, confidentialTransferFromAndCallMutationOptions, confidentialTransferFromMutationOptions, confidentialTransferMutationOptions, decryptBalanceAsMutationOptions, decryptPublicValuesMutationOptions, decryptValuesQueryOptions, delegateDecryptionMutationOptions, delegatedDecryptValuesMutationOptions, delegationStatusQueryOptions, encryptMutationOptions, filterQueryOptions, finalizeUnwrapMutationOptions, grantPermitMutationOptions, hasPermitQueryOptions, hashFn, invalidateAfterApproveUnderlying, invalidateAfterSetOperator, invalidateAfterShield, invalidateAfterTransfer, invalidateAfterUnshield, invalidateAfterUnshieldSettled, invalidateAfterUnwrap, invalidateAfterWrap, invalidateBalanceQueries, invalidateWagmiBalanceQueries, invalidateWalletLifecycleQueries, isConfidentialQueryOptions, isConfidentialTokenValidQueryOptions, isWrapperQueryOptions, listPairsQueryOptions, pendingUnshieldQueryOptions, preparePermitMutationOptions, registerPermitMutationOptions, resumeUnshieldMutationOptions, revokeDelegationMutationOptions, revokePermitsMutationOptions, shieldMutationOptions, tokenAddressQueryOptions, tokenMetadataQueryOptions, tokenPairQueryOptions, tokenPairsLengthQueryOptions, tokenPairsQueryOptions, tokenPairsSliceQueryOptions, totalSupplyQueryOptions, underlyingAllowanceQueryOptions, unshieldAllMutationOptions, unshieldMutationOptions, unwrapAllMutationOptions, unwrapMutationOptions, wrapMutationOptions, wrapperDiscoveryQueryOptions, zamaQueryKeys };
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/query/index.js

@@ -1,2 +1,2 @@
-import{f as e}from"../relayer-B6Zo6EkX.js";import{A as t,N as n,Z as r,a as i,b as a,d as o,f as s,h as c,i as l,k as u,n as d,o as f,r as ee,s as p,t as m,v as h,x as g,z as _}from"../wrappers-registry-BfQr2QHn.js";import{t as v}from"../token-BMQ6xlrk.js";import{r as y}from"../assertions-Ca1ePdRJ.js";import{getAddress as b,zeroAddress as x}from"viem";import{z as S}from"zod/mini";function te(e){if(!C(e))return!1;let t=e.constructor;if(t===void 0)return!0;let n=t.prototype;return!(!C(n)||!n.hasOwnProperty(`isPrototypeOf`))}function C(e){return Object.prototype.toString.call(e)===`[object Object]`}function w(e){let{gcTime:t,staleTime:n,enabled:r,select:i,refetchInterval:a,refetchOnMount:o,refetchOnWindowFocus:s,refetchOnReconnect:c,retry:l,retryDelay:u,retryOnMount:d,queryFn:f,queryKey:ee,queryKeyHashFn:p,initialData:m,initialDataUpdatedAt:h,placeholderData:g,structuralSharing:_,throwOnError:v,meta:y,query:b,pollingInterval:x,...S}=e;return S}function T(e){return JSON.stringify(e,(e,t)=>te(t)?Object.keys(t).sort().reduce((e,n)=>(e[n]=t[n],e),{}):typeof t==`bigint`?t.toString():t)}const E=e=>e.map(e=>b(e)),D=e=>e===void 0?void 0:b(e),O=e=>e?{walletAddress:b(e.address),walletChainId:e.chainId}:{},k={confidentialBalance:{all:[`zama.confidentialBalance`],token:e=>[`zama.confidentialBalance`,{tokenAddress:b(e)}],owner:(e,t,n)=>[`zama.confidentialBalance`,{tokenAddress:b(e),...O(n),...t?{owner:b(t)}:{}}]},confidentialBalances:{all:[`zama.confidentialBalances`],tokens:(e,t,n)=>[`zama.confidentialBalances`,{tokenAddresses:E(e),...O(n),...t?{owner:b(t)}:{}}]},tokenMetadata:{all:[`zama.tokenMetadata`],token:e=>[`zama.tokenMetadata`,{tokenAddress:b(e)}]},isConfidential:{all:[`zama.isConfidential`],token:e=>[`zama.isConfidential`,{tokenAddress:b(e)}]},isWrapper:{all:[`zama.isWrapper`],token:e=>[`zama.isWrapper`,{tokenAddress:b(e)}]},wrapperDiscovery:{all:[`zama.wrapperDiscovery`],token:(e,t,n)=>{let r=D(e),i=D(t),a=D(n);return[`zama.wrapperDiscovery`,{...r?{tokenAddress:r}:{},...i?{erc20Address:i}:{},...a?{registryAddress:a}:{}}]}},underlyingAllowance:{all:[`zama.underlyingAllowance`],token:e=>[`zama.underlyingAllowance`,{tokenAddress:b(e)}],scope:(e,t)=>[`zama.underlyingAllowance`,{tokenAddress:b(e),...t?{owner:b(t)}:{}}]},confidentialIsOperator:{all:[`zama.confidentialIsOperator`],token:e=>{let t=D(e);return[`zama.confidentialIsOperator`,t?{tokenAddress:t}:{}]},scope:(e,t,n)=>{let r=D(e),i=D(t),a=D(n);return[`zama.confidentialIsOperator`,{...r?{tokenAddress:r}:{},...i?{holder:i}:{},...a?{spender:a}:{}}]}},totalSupply:{all:[`zama.totalSupply`],token:e=>[`zama.totalSupply`,{tokenAddress:b(e)}]},pendingUnshield:{all:[`zama.pendingUnshield`],token:e=>[`zama.pendingUnshield`,{tokenAddress:b(e)}]},hasPermit:{all:[`zama.hasPermit`],scope:(e,t)=>[`zama.hasPermit`,{...O(t),contractAddresses:E(e).sort()}]},delegationStatus:{all:[`zama.delegationStatus`],contract:e=>{let t=D(e);return[`zama.delegationStatus`,t?{contractAddress:t}:{}]},scope:(e,t,n)=>{let r=D(e),i=D(t),a=D(n);return[`zama.delegationStatus`,{...r?{contractAddress:r}:{},...i?{delegatorAddress:i}:{},...a?{delegateAddress:a}:{}}]}},decryption:{all:[`zama.decryption`],encryptedValue:(e,t)=>[`zama.decryption`,{encryptedValue:e,...t===void 0?{}:{contractAddress:b(t)}}],encryptedInputs:(e,t)=>[`zama.decryption`,{...O(t),encryptedInputs:[...e].sort((e,t)=>e.encryptedValue.localeCompare(t.encryptedValue)).map(e=>({encryptedValue:e.encryptedValue,contractAddress:b(e.contractAddress)}))}]},wrappersRegistry:{all:[`zama.wrappersRegistry`],chainId:()=>[`zama.wrappersRegistry`,{type:`chainId`}],tokenPairs:e=>[`zama.wrappersRegistry`,{type:`tokenPairs`,registryAddress:b(e)}],confidentialTokenAddress:(e,t)=>[`zama.wrappersRegistry`,{type:`confidentialTokenAddress`,registryAddress:b(e),tokenAddress:b(t)}],tokenAddress:(e,t)=>[`zama.wrappersRegistry`,{type:`tokenAddress`,registryAddress:b(e),confidentialTokenAddress:b(t)}],tokenPairsLength:e=>[`zama.wrappersRegistry`,{type:`tokenPairsLength`,registryAddress:b(e)}],tokenPairsSlice:(e,t,n)=>[`zama.wrappersRegistry`,{type:`tokenPairsSlice`,registryAddress:b(e),fromIndex:t,toIndex:n}],tokenPair:(e,t)=>[`zama.wrappersRegistry`,{type:`tokenPair`,registryAddress:b(e),index:t}],isConfidentialTokenValid:(e,t)=>[`zama.wrappersRegistry`,{type:`isConfidentialTokenValid`,registryAddress:b(e),confidentialTokenAddress:b(t)}],listPairs:(e,t,n,r)=>[`zama.wrappersRegistry`,{type:`listPairs`,registryAddress:b(e),page:t,pageSize:n,metadata:r}]}};function A(e,t){e.invalidateQueries({queryKey:k.underlyingAllowance.token(t)})}function j(e,t){e.invalidateQueries({queryKey:k.pendingUnshield.token(t)})}function M(e,t){P(e,t),A(e,t),j(e,t),q(e)}function N(e,t){P(e,t),A(e,t),q(e)}function P(e,t){e.invalidateQueries({queryKey:k.confidentialBalance.token(t)}),e.invalidateQueries({queryKey:k.confidentialBalances.all})}function F(e,t){P(e,t),A(e,t),q(e)}function I(e,t){P(e,t),A(e,t),j(e,t),q(e)}function L(e,t){j(e,t)}function R(e,t){P(e,t)}function z(e,t){A(e,t)}function B(e,t){e.invalidateQueries({queryKey:k.confidentialIsOperator.token(t)})}function V(e){return Array.isArray(e.queryKey)&&typeof e.queryKey[0]==`string`?e.queryKey[0].startsWith(`zama.`):!1}const H=S.enum([`balanceOf`,`confidentialBalanceOf`]),U=S.object({functionName:H}),W=S.object({contracts:S.array(S.unknown())});function G(e){if(U.safeParse(e).success)return!0;let t=W.safeParse(e);return t.success&&t.data.contracts.some(e=>U.safeParse(e).success)}function K(e){return Array.isArray(e.queryKey)&&e.queryKey.some(G)}function q(e){e.invalidateQueries({predicate:K})}function J(e){e.removeQueries({queryKey:k.decryption.all}),e.removeQueries({queryKey:k.hasPermit.all}),e.invalidateQueries({predicate:V}),q(e)}function Y(e,t,n){let r=k.tokenMetadata.token(t);return{...w(n?.query??{}),queryKey:r,queryFn:async t=>{let[,{tokenAddress:n}]=t.queryKey,[r,i,o]=await Promise.all([e.provider.readContract(a(n)),e.provider.readContract(g(n)),e.provider.readContract(h(n))]);return{name:r,symbol:i,decimals:o}},staleTime:1/0,enabled:n?.query?.enabled!==!1}}function X(t,n,r){let i=k.isConfidential.token(n);return{...w(r?.query??{}),queryKey:i,queryFn:async n=>{let[,{tokenAddress:r}]=n.queryKey;try{return await t.provider.readContract(o(r))}catch(t){if(e(t))return!1;throw t}},staleTime:1/0,enabled:r?.query?.enabled!==!1}}function Z(t,n,r){let i=k.isWrapper.token(n);return{...w(r?.query??{}),queryKey:i,queryFn:async n=>{let[,{tokenAddress:r}]=n.queryKey;try{return await t.provider.readContract(s(r))}catch(t){if(e(t))return!1;throw t}},staleTime:1/0,enabled:r?.query?.enabled!==!1}}function Q(e,t,n){let r=k.totalSupply.token(t);return{...w(n?.query??{}),queryKey:r,queryFn:async t=>{let[,{tokenAddress:n}]=t.queryKey;return e.provider.readContract(u(n))},staleTime:3e4,enabled:n?.query?.enabled!==!1}}function ne(e,t){let n=k.wrapperDiscovery.token(t.tokenAddress,t.erc20Address,t.registryAddress);return{...w(t.query??{}),queryKey:n,queryFn:async t=>{let[,{erc20Address:n}]=t.queryKey;y(n,`wrapperDiscoveryQueryOptions: erc20Address`);let r=await e.getConfidentialToken(n);return r?r.confidentialTokenAddress:null},staleTime:1/0,enabled:!!(t.tokenAddress&&t.erc20Address&&t.registryAddress)&&t.query?.enabled!==!1}}function re(e,t,r){let i=r.owner,a=r.query?.enabled!==!1,o=k.underlyingAllowance.scope(t,i);return{...w(r.query??{}),queryKey:o,queryFn:async t=>{let[,{tokenAddress:r,owner:i}]=t.queryKey;y(i,`underlyingAllowanceQueryOptions: owner`);let a=await e.provider.readContract(n(r));return e.provider.readContract(c(a,i,r))},staleTime:3e4,enabled:!!i&&a}}function ie(e,t,n){let r=k.pendingUnshield.token(t);return{...w(n?.query??{}),queryKey:r,queryFn:async t=>{let[,{tokenAddress:n}]=t.queryKey;return e.createWrappedToken(n).getPendingUnshield()},staleTime:0,enabled:n?.query?.enabled!==!1}}function ae(e,n,r){let i=r.holder,a=r.spender,o=r.query?.enabled!==!1,s=k.confidentialIsOperator.scope(n,i,a);return{...w(r.query??{}),queryKey:s,queryFn:async n=>{let[,{tokenAddress:r,holder:i,spender:a}]=n.queryKey;return y(r,`confidentialIsOperatorQueryOptions: tokenAddress`),y(i,`confidentialIsOperatorQueryOptions: holder`),y(a,`confidentialIsOperatorQueryOptions: spender`),e.provider.readContract(t(r,i,a))},staleTime:3e4,enabled:!!(n&&i&&a)&&o}}function oe(e,t,n={}){let r=t.query??{};return{...w(r),queryKey:k.confidentialBalance.owner(t.tokenAddress,t.account,n.walletAccount),queryFn:async t=>{let[,{owner:n}]=t.queryKey;return y(n,`confidentialBalanceQueryOptions: owner`),e.balanceOf(n)},enabled:!!t.account&&n.walletAccount!==void 0&&r?.enabled!==!1}}function se(e,t,n={}){let r=t?.account,i=n.walletAccount,a=t?.query??{},o=e.map(e=>e.address);return{...w(a),queryKey:k.confidentialBalances.tokens(o,r,i),queryFn:async t=>{let[,{owner:n}]=t.queryKey;return y(n,`confidentialBalancesQueryOptions: owner`),v.batchBalancesOf(e,n)},enabled:!!r&&e.length>0&&i!==void 0&&a?.enabled!==!1}}function ce(e,t){let n=!!t.registryAddress&&t.query?.enabled!==!1,r=k.wrappersRegistry.tokenPairs(t.registryAddress??x);return{...w(t.query??{}),queryKey:r,queryFn:async t=>{let[,{registryAddress:n}]=t.queryKey;return e.provider.readContract(l(n))},staleTime:e.registry.ttlMs,enabled:n}}function le(e,t){let n=!!t.registryAddress&&!!t.tokenAddress&&t.query?.enabled!==!1,r=k.wrappersRegistry.confidentialTokenAddress(t.registryAddress??x,t.tokenAddress??x);return{...w(t.query??{}),queryKey:r,queryFn:async t=>{let[,{registryAddress:n,tokenAddress:r}]=t.queryKey;return e.provider.readContract(m(n,r))},staleTime:e.registry.ttlMs,enabled:n}}function ue(e,t){let n=!!t.registryAddress&&!!t.confidentialTokenAddress&&t.query?.enabled!==!1,r=k.wrappersRegistry.tokenAddress(t.registryAddress??x,t.confidentialTokenAddress??x);return{...w(t.query??{}),queryKey:r,queryFn:async t=>{let[,{registryAddress:n,confidentialTokenAddress:r}]=t.queryKey;return e.provider.readContract(d(n,r))},staleTime:e.registry.ttlMs,enabled:n}}function de(e,t){let n=!!t.registryAddress&&t.query?.enabled!==!1,r=k.wrappersRegistry.tokenPairsLength(t.registryAddress??x);return{...w(t.query??{}),queryKey:r,queryFn:async t=>{let[,{registryAddress:n}]=t.queryKey;return e.provider.readContract(i(n))},staleTime:e.registry.ttlMs,enabled:n}}function fe(e,t){let n=!!t.registryAddress&&t.fromIndex!==void 0&&t.toIndex!==void 0&&t.query?.enabled!==!1,r=k.wrappersRegistry.tokenPairsSlice(t.registryAddress??x,String(t.fromIndex??0n),String(t.toIndex??0n));return{...w(t.query??{}),queryKey:r,queryFn:async t=>{let[,{registryAddress:n,fromIndex:r,toIndex:i}]=t.queryKey;return e.provider.readContract(f(n,BigInt(r),BigInt(i)))},staleTime:e.registry.ttlMs,enabled:n}}function pe(e,t){let n=!!t.registryAddress&&t.index!==void 0&&t.query?.enabled!==!1,r=k.wrappersRegistry.tokenPair(t.registryAddress??x,String(t.index??0n));return{...w(t.query??{}),queryKey:r,queryFn:async t=>{let[,{registryAddress:n,index:r}]=t.queryKey;return e.provider.readContract(ee(n,BigInt(r)))},staleTime:e.registry.ttlMs,enabled:n}}function me(e,t){let n=!!t.registryAddress&&!!t.confidentialTokenAddress&&t.query?.enabled!==!1,r=k.wrappersRegistry.isConfidentialTokenValid(t.registryAddress??x,t.confidentialTokenAddress??x);return{...w(t.query??{}),queryKey:r,queryFn:async t=>{let[,{registryAddress:n,confidentialTokenAddress:r}]=t.queryKey;return e.provider.readContract(p(n,r))},staleTime:e.registry.ttlMs,enabled:n}}function he(e,t){let n=!!t.registryAddress&&t.query?.enabled!==!1,r=k.wrappersRegistry.listPairs(t.registryAddress??x,t.page??1,t.pageSize??100,t.metadata??!1);return{...w(t.query??{}),queryKey:r,queryFn:async t=>{let[,{page:n,pageSize:r,metadata:i}]=t.queryKey;return e.listPairs({page:n,pageSize:r,metadata:i})},staleTime:e.ttlMs,enabled:n}}function ge(e){return{mutationKey:[`zama.shield`,e.address],mutationFn:async({amount:t,...n})=>e.shield(t,n)}}function _e(e){return{mutationKey:[`zama.confidentialTransfer`,e.address],mutationFn:async({to:t,amount:n,...r})=>e.confidentialTransfer(t,n,r)}}function ve(e){return{mutationKey:[`zama.confidentialTransferAndCall`,e.address],mutationFn:async({to:t,amount:n,data:r,...i})=>e.confidentialTransferAndCall(t,n,r,i)}}function ye(e){return{mutationKey:[`zama.confidentialTransferFrom`,e.address],mutationFn:async({from:t,to:n,amount:r,callbacks:i})=>e.confidentialTransferFrom(t,n,r,i)}}function be(e){return{mutationKey:[`zama.confidentialTransferFromAndCall`,e.address],mutationFn:async({from:t,to:n,amount:r,data:i,callbacks:a})=>e.confidentialTransferFromAndCall(t,n,r,i,a)}}function xe(e){return{mutationKey:[`zama.confidentialSetOperator`,e.address],mutationFn:async({operator:t,until:n})=>e.setOperator(t,n)}}function Se(e){return{mutationKey:[`zama.approveUnderlying`,e.address],mutationFn:async({amount:t})=>e.approveUnderlying(t)}}function Ce(e){return{mutationKey:[`zama.unshield`,e.address],mutationFn:async({amount:t,...n})=>e.unshield(t,n)}}function we(e){return{mutationKey:[`zama.unshieldAll`,e.address],mutationFn:async t=>e.unshieldAll(t||void 0)}}function Te(e){return{mutationKey:[`zama.resumeUnshield`,e.address],mutationFn:async({unwrapTxHash:t,...n})=>e.resumeUnshield(t,n)}}function Ee(e){return{mutationKey:[`zama.unwrap`,e.address],mutationFn:async({amount:t})=>e.unwrap(t)}}function De(e){return{mutationKey:[`zama.wrap`,e.address],mutationFn:async({amount:t,...n})=>e.wrap(t,n)}}function Oe(e){return{mutationKey:[`zama.unwrapAll`,e.address],mutationFn:async()=>e.unwrapAll()}}function ke(e){return{mutationKey:[`zama.finalizeUnwrap`,e.address],mutationFn:async({unwrapRequestId:t})=>e.finalizeUnwrap(t)}}function Ae(e){return{mutationKey:[`zama.encrypt`],mutationFn:async t=>e.encrypt(t)}}function je(e){return{mutationKey:[`zama.delegatedDecryptValues`],mutationFn:async t=>e.decryption.delegatedDecryptValues(t.encryptedInputs,t.delegatorAddress)}}function Me(e){return{mutationKey:[`zama.decryptPublicValues`],mutationFn:async t=>e.decryption.decryptPublicValues(t),onSuccess:(e,t,n,r)=>{for(let[t,n]of Object.entries(e.clearValues))r.client.setQueryData(k.decryption.encryptedValue(t),n)}}}function Ne(e){return{mutationKey:[`zama.grantPermit`],mutationFn:t=>e.permits.grantPermit(t)}}function Pe(e){return{mutationKey:[`zama.preparePermit`],mutationFn:t=>e.offline.preparePermit(t)}}function $(e){return{mutationKey:[`zama.registerPermit`],mutationFn:({prepared:t,signature:n})=>e.permits.registerPermit(t,n)}}function Fe(e,t,n={}){let r=t.query?.enabled!==!1;return{...w(t?.query??{}),queryKey:k.hasPermit.scope(t.contractAddresses,n.walletAccount),queryFn:t=>{let[,{contractAddresses:n}]=t.queryKey;return e.permits.hasPermit(n)},staleTime:0,gcTime:0,refetchOnMount:`always`,refetchOnWindowFocus:!1,enabled:r&&n.walletAccount!==void 0&&t.contractAddresses.length>0}}function Ie(e){return{mutationKey:[`zama.revokePermits`],mutationFn:t=>t===void 0?e.permits.revokePermits():e.permits.revokePermits(t)}}function Le(e){return{mutationKey:[`zama.clearCredentials`],mutationFn:()=>e.permits.clear()}}function Re(e,t){return{mutationKey:[`zama.delegateDecryption`,t],mutationFn:async({delegateAddress:n,expirationDate:r})=>e.delegations.delegateDecryption({contractAddress:t,delegateAddress:n,expirationDate:r})}}function ze(e,t,n={}){return{queryKey:k.decryption.encryptedInputs(t,n.walletAccount),queryFn:t=>{let[,{encryptedInputs:n}]=t.queryKey;return e.decryption.decryptValues(n)},staleTime:1/0,enabled:t.length>0&&n.walletAccount!==void 0}}function Be(e){return{mutationKey:[`zama.decryptBalanceAs`,e.address],mutationFn:async({delegatorAddress:t,accountAddress:n})=>e.decryptBalanceAs({delegatorAddress:t,accountAddress:n})}}function Ve(e){return{mutationKey:[`zama.batchDecryptBalancesAs`,...e.map(e=>e.address)],mutationFn:async t=>v.batchDecryptBalancesAs(e,t)}}function He(e,t){return{mutationKey:[`zama.revokeDelegation`,t],mutationFn:async({delegateAddress:n})=>e.delegations.revokeDelegation({contractAddress:t,delegateAddress:n})}}function Ue(e){return{mutationKey:[`zama.invalidateDecryptionSignatures`],mutationFn:async t=>e.permits.invalidateDecryptionSignatures(t?.timestamp)}}function We(e,t){return{...w(t.query??{}),queryKey:k.delegationStatus.scope(t.contractAddress,t.delegatorAddress,t.delegateAddress),queryFn:async t=>{let[,{contractAddress:n,delegatorAddress:r,delegateAddress:i}]=t.queryKey;return y(n,`delegationStatusQueryOptions: contractAddress`),y(r,`delegationStatusQueryOptions: delegatorAddress`),y(i,`delegationStatusQueryOptions: delegateAddress`),e.delegations.getStatus({contractAddress:n,delegatorAddress:r,delegateAddress:i})},enabled:!!(t.contractAddress&&t.delegatorAddress&&t.delegateAddress)&&t.query?.enabled!==!1}}export{_ as WILDCARD_PERMIT,r as ZamaSDKEvents,Se as approveUnderlyingMutationOptions,Ve as batchDecryptBalancesAsMutationOptions,Le as clearCredentialsMutationOptions,oe as confidentialBalanceQueryOptions,se as confidentialBalancesQueryOptions,ae as confidentialIsOperatorQueryOptions,xe as confidentialSetOperatorMutationOptions,le as confidentialTokenAddressQueryOptions,ve as confidentialTransferAndCallMutationOptions,be as confidentialTransferFromAndCallMutationOptions,ye as confidentialTransferFromMutationOptions,_e as confidentialTransferMutationOptions,Be as decryptBalanceAsMutationOptions,Me as decryptPublicValuesMutationOptions,ze as decryptValuesQueryOptions,Re as delegateDecryptionMutationOptions,je as delegatedDecryptValuesMutationOptions,We as delegationStatusQueryOptions,Ae as encryptMutationOptions,w as filterQueryOptions,ke as finalizeUnwrapMutationOptions,Ne as grantPermitMutationOptions,Fe as hasPermitQueryOptions,T as hashFn,z as invalidateAfterApproveUnderlying,B as invalidateAfterSetOperator,F as invalidateAfterShield,R as invalidateAfterTransfer,I as invalidateAfterUnshield,L as invalidateAfterUnshieldSettled,M as invalidateAfterUnwrap,N as invalidateAfterWrap,P as invalidateBalanceQueries,Ue as invalidateDecryptionSignaturesMutationOptions,q as invalidateWagmiBalanceQueries,J as invalidateWalletLifecycleQueries,X as isConfidentialQueryOptions,me as isConfidentialTokenValidQueryOptions,Z as isWrapperQueryOptions,he as listPairsQueryOptions,ie as pendingUnshieldQueryOptions,Pe as preparePermitMutationOptions,$ as registerPermitMutationOptions,Te as resumeUnshieldMutationOptions,He as revokeDelegationMutationOptions,Ie as revokePermitsMutationOptions,ge as shieldMutationOptions,ue as tokenAddressQueryOptions,Y as tokenMetadataQueryOptions,pe as tokenPairQueryOptions,de as tokenPairsLengthQueryOptions,ce as tokenPairsQueryOptions,fe as tokenPairsSliceQueryOptions,Q as totalSupplyQueryOptions,re as underlyingAllowanceQueryOptions,we as unshieldAllMutationOptions,Ce as unshieldMutationOptions,Oe as unwrapAllMutationOptions,Ee as unwrapMutationOptions,De as wrapMutationOptions,ne as wrapperDiscoveryQueryOptions,k as zamaQueryKeys};
+import{f as e}from"../relayer-CVKO9GmQ.js";import{C as t,E as n,M as r,S as i,a,c as o,d as s,i as c,m as l,p as u}from"../erc165-DbMOt-s6.js";import{t as d}from"../token-CRJ8eCr7.js";import{a as f,i as ee,n as p,o as m,r as h,s as g,t as _}from"../wrappers-registry-Cm3JJeqx.js";import{r as v}from"../assertions-Ca1ePdRJ.js";import{a as y,c as b,d as x,f as S,i as C,l as w,m as T,n as E,o as D,p as O,r as k,s as A,t as j,u as M}from"../invalidation-BgFjmXeQ.js";import{zeroAddress as N}from"viem";function P(e,t,n){let r=S.tokenMetadata.token(t);return{...O(n?.query??{}),queryKey:r,queryFn:async t=>{let[,{tokenAddress:n}]=t.queryKey,[r,i,a]=await Promise.all([e.provider.readContract(u(n)),e.provider.readContract(l(n)),e.provider.readContract(s(n))]);return{name:r,symbol:i,decimals:a}},staleTime:1/0,enabled:n?.query?.enabled!==!1}}function F(t,n,r){let i=S.isConfidential.token(n);return{...O(r?.query??{}),queryKey:i,queryFn:async n=>{let[,{tokenAddress:r}]=n.queryKey;try{return await t.provider.readContract(c(r))}catch(t){if(e(t))return!1;throw t}},staleTime:1/0,enabled:r?.query?.enabled!==!1}}function I(t,n,r){let i=S.isWrapper.token(n);return{...O(r?.query??{}),queryKey:i,queryFn:async n=>{let[,{tokenAddress:r}]=n.queryKey;try{return await t.provider.readContract(a(r))}catch(t){if(e(t))return!1;throw t}},staleTime:1/0,enabled:r?.query?.enabled!==!1}}function L(e,t,n){let r=S.totalSupply.token(t);return{...O(n?.query??{}),queryKey:r,queryFn:async t=>{let[,{tokenAddress:n}]=t.queryKey;return e.provider.readContract(i(n))},staleTime:3e4,enabled:n?.query?.enabled!==!1}}function R(e,t){let n=S.wrapperDiscovery.token(t.tokenAddress,t.erc20Address,t.registryAddress);return{...O(t.query??{}),queryKey:n,queryFn:async t=>{let[,{erc20Address:n}]=t.queryKey;v(n,`wrapperDiscoveryQueryOptions: erc20Address`);let r=await e.getConfidentialToken(n);return r?r.confidentialTokenAddress:null},staleTime:1/0,enabled:!!(t.tokenAddress&&t.erc20Address&&t.registryAddress)&&t.query?.enabled!==!1}}function z(e,t,r){let i=r.owner,a=r.query?.enabled!==!1,s=S.underlyingAllowance.scope(t,i);return{...O(r.query??{}),queryKey:s,queryFn:async t=>{let[,{tokenAddress:r,owner:i}]=t.queryKey;v(i,`underlyingAllowanceQueryOptions: owner`);let a=await e.provider.readContract(n(r));return e.provider.readContract(o(a,i,r))},staleTime:3e4,enabled:!!i&&a}}function B(e,t,n){let r=S.pendingUnshield.token(t);return{...O(n?.query??{}),queryKey:r,queryFn:async t=>{let[,{tokenAddress:n}]=t.queryKey;return e.createWrappedToken(n).getPendingUnshield()},staleTime:0,enabled:n?.query?.enabled!==!1}}function V(e,n,r){let i=r.holder,a=r.spender,o=r.query?.enabled!==!1,s=S.confidentialIsOperator.scope(n,i,a);return{...O(r.query??{}),queryKey:s,queryFn:async n=>{let[,{tokenAddress:r,holder:i,spender:a}]=n.queryKey;return v(r,`confidentialIsOperatorQueryOptions: tokenAddress`),v(i,`confidentialIsOperatorQueryOptions: holder`),v(a,`confidentialIsOperatorQueryOptions: spender`),e.provider.readContract(t(r,i,a))},staleTime:3e4,enabled:!!(n&&i&&a)&&o}}function H(e,t,n={}){let r=t.query??{};return{...O(r),queryKey:S.confidentialBalance.owner(t.tokenAddress,t.account,n.walletAccount),queryFn:async t=>{let[,{owner:n}]=t.queryKey;return v(n,`confidentialBalanceQueryOptions: owner`),e.balanceOf(n)},enabled:!!t.account&&n.walletAccount!==void 0&&r?.enabled!==!1}}function U(e,t,n={}){let r=t?.account,i=n.walletAccount,a=t?.query??{},o=e.map(e=>e.address);return{...O(a),queryKey:S.confidentialBalances.tokens(o,r,i),queryFn:async t=>{let[,{owner:n}]=t.queryKey;return v(n,`confidentialBalancesQueryOptions: owner`),d.batchBalancesOf(e,n)},enabled:!!r&&e.length>0&&i!==void 0&&a?.enabled!==!1}}function W(e,t){let n=!!t.registryAddress&&t.query?.enabled!==!1,r=S.wrappersRegistry.tokenPairs(t.registryAddress??N);return{...O(t.query??{}),queryKey:r,queryFn:async t=>{let[,{registryAddress:n}]=t.queryKey;return e.provider.readContract(ee(n))},staleTime:e.registry.ttlMs,enabled:n}}function G(e,t){let n=!!t.registryAddress&&!!t.tokenAddress&&t.query?.enabled!==!1,r=S.wrappersRegistry.confidentialTokenAddress(t.registryAddress??N,t.tokenAddress??N);return{...O(t.query??{}),queryKey:r,queryFn:async t=>{let[,{registryAddress:n,tokenAddress:r}]=t.queryKey;return e.provider.readContract(_(n,r))},staleTime:e.registry.ttlMs,enabled:n}}function K(e,t){let n=!!t.registryAddress&&!!t.confidentialTokenAddress&&t.query?.enabled!==!1,r=S.wrappersRegistry.tokenAddress(t.registryAddress??N,t.confidentialTokenAddress??N);return{...O(t.query??{}),queryKey:r,queryFn:async t=>{let[,{registryAddress:n,confidentialTokenAddress:r}]=t.queryKey;return e.provider.readContract(p(n,r))},staleTime:e.registry.ttlMs,enabled:n}}function q(e,t){let n=!!t.registryAddress&&t.query?.enabled!==!1,r=S.wrappersRegistry.tokenPairsLength(t.registryAddress??N);return{...O(t.query??{}),queryKey:r,queryFn:async t=>{let[,{registryAddress:n}]=t.queryKey;return e.provider.readContract(f(n))},staleTime:e.registry.ttlMs,enabled:n}}function J(e,t){let n=!!t.registryAddress&&t.fromIndex!==void 0&&t.toIndex!==void 0&&t.query?.enabled!==!1,r=S.wrappersRegistry.tokenPairsSlice(t.registryAddress??N,String(t.fromIndex??0n),String(t.toIndex??0n));return{...O(t.query??{}),queryKey:r,queryFn:async t=>{let[,{registryAddress:n,fromIndex:r,toIndex:i}]=t.queryKey;return e.provider.readContract(m(n,BigInt(r),BigInt(i)))},staleTime:e.registry.ttlMs,enabled:n}}function te(e,t){let n=!!t.registryAddress&&t.index!==void 0&&t.query?.enabled!==!1,r=S.wrappersRegistry.tokenPair(t.registryAddress??N,String(t.index??0n));return{...O(t.query??{}),queryKey:r,queryFn:async t=>{let[,{registryAddress:n,index:r}]=t.queryKey;return e.provider.readContract(h(n,BigInt(r)))},staleTime:e.registry.ttlMs,enabled:n}}function Y(e,t){let n=!!t.registryAddress&&!!t.confidentialTokenAddress&&t.query?.enabled!==!1,r=S.wrappersRegistry.isConfidentialTokenValid(t.registryAddress??N,t.confidentialTokenAddress??N);return{...O(t.query??{}),queryKey:r,queryFn:async t=>{let[,{registryAddress:n,confidentialTokenAddress:r}]=t.queryKey;return e.provider.readContract(g(n,r))},staleTime:e.registry.ttlMs,enabled:n}}function X(e,t){let n=!!t.registryAddress&&t.query?.enabled!==!1,r=S.wrappersRegistry.listPairs(t.registryAddress??N,t.page??1,t.pageSize??100,t.metadata??!1);return{...O(t.query??{}),queryKey:r,queryFn:async t=>{let[,{page:n,pageSize:r,metadata:i}]=t.queryKey;return e.listPairs({page:n,pageSize:r,metadata:i})},staleTime:e.ttlMs,enabled:n}}function Z(e){return{mutationKey:[`zama.shield`,e.address],mutationFn:async({amount:t,...n})=>e.shield(t,n)}}function Q(e){return{mutationKey:[`zama.confidentialTransfer`,e.address],mutationFn:async({to:t,amount:n,...r})=>e.confidentialTransfer(t,n,r)}}function ne(e){return{mutationKey:[`zama.confidentialTransferAndCall`,e.address],mutationFn:async({to:t,amount:n,data:r,...i})=>e.confidentialTransferAndCall(t,n,r,i)}}function re(e){return{mutationKey:[`zama.confidentialTransferFrom`,e.address],mutationFn:async({from:t,to:n,amount:r,callbacks:i})=>e.confidentialTransferFrom(t,n,r,i)}}function ie(e){return{mutationKey:[`zama.confidentialTransferFromAndCall`,e.address],mutationFn:async({from:t,to:n,amount:r,data:i,callbacks:a})=>e.confidentialTransferFromAndCall(t,n,r,i,a)}}function ae(e){return{mutationKey:[`zama.confidentialSetOperator`,e.address],mutationFn:async({operator:t,until:n})=>e.setOperator(t,n)}}function oe(e){return{mutationKey:[`zama.approveUnderlying`,e.address],mutationFn:async({amount:t})=>e.approveUnderlying(t)}}function se(e){return{mutationKey:[`zama.unshield`,e.address],mutationFn:async({amount:t,...n})=>e.unshield(t,n)}}function ce(e){return{mutationKey:[`zama.unshieldAll`,e.address],mutationFn:async t=>e.unshieldAll(t||void 0)}}function le(e){return{mutationKey:[`zama.resumeUnshield`,e.address],mutationFn:async({unwrapTxHash:t,...n})=>e.resumeUnshield(t,n)}}function ue(e){return{mutationKey:[`zama.unwrap`,e.address],mutationFn:async({amount:t})=>e.unwrap(t)}}function de(e){return{mutationKey:[`zama.wrap`,e.address],mutationFn:async({amount:t,...n})=>e.wrap(t,n)}}function fe(e){return{mutationKey:[`zama.unwrapAll`,e.address],mutationFn:async()=>e.unwrapAll()}}function pe(e){return{mutationKey:[`zama.finalizeUnwrap`,e.address],mutationFn:async({unwrapRequestId:t})=>e.finalizeUnwrap(t)}}function me(e){return{mutationKey:[`zama.encrypt`],mutationFn:async t=>e.encrypt(t)}}function he(e){return{mutationKey:[`zama.delegatedDecryptValues`],mutationFn:async t=>e.decryption.delegatedDecryptValues(t.encryptedInputs,t.delegatorAddress)}}function ge(e){return{mutationKey:[`zama.decryptPublicValues`],mutationFn:async t=>e.decryption.decryptPublicValues(t),onSuccess:(e,t,n,r)=>{for(let[t,n]of Object.entries(e.clearValues))r.client.setQueryData(S.decryption.encryptedValue(t),n)}}}function _e(e){return{mutationKey:[`zama.grantPermit`],mutationFn:t=>e.permits.grantPermit(t)}}function ve(e){return{mutationKey:[`zama.preparePermit`],mutationFn:t=>e.offline.preparePermit(t)}}function ye(e){return{mutationKey:[`zama.registerPermit`],mutationFn:({prepared:t,signature:n})=>e.permits.registerPermit(t,n)}}function be(e,t,n={}){let r=t.query?.enabled!==!1;return{...O(t?.query??{}),queryKey:S.hasPermit.scope(t.contractAddresses,n.walletAccount),queryFn:t=>{let[,{contractAddresses:n}]=t.queryKey;return e.permits.hasPermit(n)},staleTime:0,gcTime:0,refetchOnMount:`always`,refetchOnWindowFocus:!1,enabled:r&&n.walletAccount!==void 0&&t.contractAddresses.length>0}}function $(e){return{mutationKey:[`zama.revokePermits`],mutationFn:t=>t===void 0?e.permits.revokePermits():e.permits.revokePermits(t)}}function xe(e){return{mutationKey:[`zama.clearCredentials`],mutationFn:()=>e.permits.clear()}}function Se(e,t){return{mutationKey:[`zama.delegateDecryption`,t],mutationFn:async({delegateAddress:n,expirationDate:r})=>e.delegations.delegateDecryption({contractAddress:t,delegateAddress:n,expirationDate:r})}}function Ce(e,t,n={}){return{queryKey:S.decryption.encryptedInputs(t,n.walletAccount),queryFn:t=>{let[,{encryptedInputs:n}]=t.queryKey;return e.decryption.decryptValues(n)},staleTime:1/0,enabled:t.length>0&&n.walletAccount!==void 0}}function we(e){return{mutationKey:[`zama.decryptBalanceAs`,e.address],mutationFn:async({delegatorAddress:t,accountAddress:n})=>e.decryptBalanceAs({delegatorAddress:t,accountAddress:n})}}function Te(e){return{mutationKey:[`zama.batchDecryptBalancesAs`,...e.map(e=>e.address)],mutationFn:async t=>d.batchDecryptBalancesAs(e,t)}}function Ee(e,t){return{mutationKey:[`zama.revokeDelegation`,t],mutationFn:async({delegateAddress:n})=>e.delegations.revokeDelegation({contractAddress:t,delegateAddress:n})}}function De(e,t){return{...O(t.query??{}),queryKey:S.delegationStatus.scope(t.contractAddress,t.delegatorAddress,t.delegateAddress),queryFn:async t=>{let[,{contractAddress:n,delegatorAddress:r,delegateAddress:i}]=t.queryKey;return v(n,`delegationStatusQueryOptions: contractAddress`),v(r,`delegationStatusQueryOptions: delegatorAddress`),v(i,`delegationStatusQueryOptions: delegateAddress`),e.delegations.getStatus({contractAddress:n,delegatorAddress:r,delegateAddress:i})},enabled:!!(t.contractAddress&&t.delegatorAddress&&t.delegateAddress)&&t.query?.enabled!==!1}}export{r as ZamaSDKEvents,oe as approveUnderlyingMutationOptions,Te as batchDecryptBalancesAsMutationOptions,xe as clearCredentialsMutationOptions,H as confidentialBalanceQueryOptions,U as confidentialBalancesQueryOptions,V as confidentialIsOperatorQueryOptions,ae as confidentialSetOperatorMutationOptions,G as confidentialTokenAddressQueryOptions,ne as confidentialTransferAndCallMutationOptions,ie as confidentialTransferFromAndCallMutationOptions,re as confidentialTransferFromMutationOptions,Q as confidentialTransferMutationOptions,we as decryptBalanceAsMutationOptions,ge as decryptPublicValuesMutationOptions,Ce as decryptValuesQueryOptions,Se as delegateDecryptionMutationOptions,he as delegatedDecryptValuesMutationOptions,De as delegationStatusQueryOptions,me as encryptMutationOptions,O as filterQueryOptions,pe as finalizeUnwrapMutationOptions,_e as grantPermitMutationOptions,be as hasPermitQueryOptions,T as hashFn,j as invalidateAfterApproveUnderlying,E as invalidateAfterSetOperator,k as invalidateAfterShield,C as invalidateAfterTransfer,y as invalidateAfterUnshield,D as invalidateAfterUnshieldSettled,A as invalidateAfterUnwrap,b as invalidateAfterWrap,w as invalidateBalanceQueries,M as invalidateWagmiBalanceQueries,x as invalidateWalletLifecycleQueries,F as isConfidentialQueryOptions,Y as isConfidentialTokenValidQueryOptions,I as isWrapperQueryOptions,X as listPairsQueryOptions,B as pendingUnshieldQueryOptions,ve as preparePermitMutationOptions,ye as registerPermitMutationOptions,le as resumeUnshieldMutationOptions,Ee as revokeDelegationMutationOptions,$ as revokePermitsMutationOptions,Z as shieldMutationOptions,K as tokenAddressQueryOptions,P as tokenMetadataQueryOptions,te as tokenPairQueryOptions,q as tokenPairsLengthQueryOptions,W as tokenPairsQueryOptions,J as tokenPairsSliceQueryOptions,L as totalSupplyQueryOptions,z as underlyingAllowanceQueryOptions,ce as unshieldAllMutationOptions,se as unshieldMutationOptions,fe as unwrapAllMutationOptions,ue as unwrapMutationOptions,de as wrapMutationOptions,R as wrapperDiscoveryQueryOptions,S as zamaQueryKeys};
 //# sourceMappingURL=index.js.map