@zama-fhe/react-sdk 1.0.0-alpha.15 → 1.0.0-alpha.16

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/dist/index.d.ts +635 -582
  2. package/dist/index.js +1 -781
  3. package/dist/index.js.map +1 -1
  4. package/dist/wagmi/index.d.ts +21 -13
  5. package/dist/wagmi/index.js +1 -75
  6. package/dist/wagmi/index.js.map +1 -1
  7. package/package.json +5 -4
package/dist/index.d.ts CHANGED
@@ -1,42 +1,43 @@
1
- import * as react_jsx_runtime from 'react/jsx-runtime';
2
- import * as _zama_fhe_sdk from '@zama-fhe/sdk';
3
- import { RelayerSDK, GenericSigner, GenericStorage, ZamaSDKEventListener, ZamaSDK, EncryptResult, EncryptParams, ClearValueType, UserDecryptParams, PublicDecryptResult, KeypairType, EIP712TypedData, Address, DelegatedUserDecryptParams, ZKProofLike, Handle, Hex, TransactionResult, RawLog, ActivityLogMetadata, ActivityItem } from '@zama-fhe/sdk';
4
- export { ActivityAmount, ActivityDirection, ActivityItem, ActivityLogMetadata, ActivityType, Address, ApprovalFailedError, ApproveSubmittedEvent, ApproveUnderlyingSubmittedEvent, BATCH_SWAP_ABI, BaseEvent, BatchDecryptOptions, BatchTransferData, ChromeSessionStorage, ClearValueType, ConfidentialTransferEvent, ContractAbi, CredentialsAllowedEvent, CredentialsCachedEvent, CredentialsCreatedEvent, CredentialsCreatingEvent, CredentialsExpiredEvent, CredentialsLoadingEvent, CredentialsManager, CredentialsManagerConfig, CredentialsRevokedEvent, DEPLOYMENT_COORDINATOR_ABI, DecryptEndEvent, DecryptErrorEvent, DecryptStartEvent, DecryptionFailedError, DelegatedUserDecryptParams, EIP712TypedData, ENCRYPTION_ABI, ERC165_ABI, ERC20_ABI, ERC20_METADATA_ABI, ERC7984_INTERFACE_ID, ERC7984_WRAPPER_INTERFACE_ID, EncryptEndEvent, EncryptErrorEvent, EncryptInput, EncryptParams, EncryptResult, EncryptStartEvent, EncryptionFailedError, FEE_MANAGER_ABI, FheTypeName, FhevmInstanceConfig, FinalizeUnwrapSubmittedEvent, GenericSigner, GenericStorage, Handle, HardhatConfig, Hex, IndexedDBStorage, InputProofBytesType, InvalidKeypairError, KeypairExpiredError, KeypairType, KmsDelegatedUserDecryptEIP712Type, MainnetConfig, MemoryStorage, NetworkType, NoCiphertextError, OnChainEvent, PublicDecryptResult, RawLog, ReadContractArgs, ReadContractConfig, ReadContractReturnType, ReadFunctionName, ReadonlyToken, ReadonlyTokenConfig, RelayerRequestFailedError, RelayerSDK, RelayerSDKStatus, RelayerWeb, RelayerWebConfig, RelayerWebSecurityConfig, SepoliaConfig, SessionExpiredEvent, ShieldCallbacks, ShieldSubmittedEvent, SigningFailedError, SigningRejectedError, StoredCredentials, TOKEN_TOPICS, TRANSFER_BATCHER_ABI, Token, TokenConfig, Topics, TransactionErrorEvent, TransactionReceipt, TransactionResult, TransactionRevertedError, TransferCallbacks, TransferFromSubmittedEvent, TransferSubmittedEvent, UnshieldCallbacks, UnshieldPhase1SubmittedEvent, UnshieldPhase2StartedEvent, UnshieldPhase2SubmittedEvent, UnwrapRequestedEvent, UnwrapSubmittedEvent, UnwrappedFinalizedEvent, UnwrappedStartedEvent, UserDecryptParams, WRAPPER_ABI, WrappedEvent, WriteContractArgs, WriteContractConfig, WriteFunctionName, ZERO_HANDLE, ZKProofLike, ZamaError, ZamaErrorCode, ZamaSDK, ZamaSDKConfig, ZamaSDKEvent, ZamaSDKEventInput, ZamaSDKEventListener, ZamaSDKEventType, ZamaSDKEvents, allowanceContract, applyDecryptedValues, approveContract, balanceOfContract, chromeSessionStorage, clearPendingUnshield, confidentialBalanceOfContract, confidentialBatchTransferContract, confidentialTotalSupplyContract, confidentialTransferContract, confidentialTransferFromContract, decimalsContract, decodeConfidentialTransfer, decodeOnChainEvent, decodeOnChainEvents, decodeUnwrapRequested, decodeUnwrappedFinalized, decodeUnwrappedStarted, decodeWrapped, deploymentCoordinatorContract, extractEncryptedHandles, finalizeUnwrapContract, findUnwrapRequested, findWrapped, getBatchTransferFeeContract, getFeeRecipientContract, getUnwrapFeeContract, getWrapFeeContract, getWrapperContract, indexedDBStorage, isConfidentialTokenContract, isConfidentialWrapperContract, isFinalizeUnwrapOperatorContract, isOperatorContract, loadPendingUnshield, matchZamaError, nameContract, parseActivityFeed, rateContract, savePendingUnshield, setFinalizeUnwrapOperatorContract, setOperatorContract, sortByBlockNumber, supportsInterfaceContract, symbolContract, totalSupplyContract, underlyingContract, unwrapContract, unwrapFromBalanceContract, wrapContract, wrapETHContract, wrapperExistsContract } from '@zama-fhe/sdk';
5
- import { PropsWithChildren } from 'react';
6
- import * as _tanstack_react_query from '@tanstack/react-query';
7
- import { UseQueryOptions, UseMutationOptions, QueryKey } from '@tanstack/react-query';
8
- import * as _zama_fhe_relayer_sdk_web from '@zama-fhe/relayer-sdk/web';
9
- import * as _tanstack_query_core from '@tanstack/query-core';
10
- import { ConfidentialBalancesData, ConfidentialTransferParams, ConfidentialTransferFromParams, ConfidentialApproveParams, ShieldParams, ShieldETHParams, UnwrapParams, FinalizeUnwrapParams, UnshieldParams, UnshieldAllParams, ResumeUnshieldParams, TokenMetadata, ApproveUnderlyingParams } from '@zama-fhe/sdk/query';
11
- export { ApproveUnderlyingParams, ConfidentialApproveParams, ConfidentialBalancesData, ConfidentialTransferFromParams, ConfidentialTransferParams, FinalizeUnwrapParams, ResumeUnshieldParams, ShieldETHParams, ShieldParams, TokenMetadata, UnshieldAllParams, UnshieldParams, UnwrapParams, activityFeedQueryOptions, allowMutationOptions, approveUnderlyingMutationOptions, batchTransferFeeQueryOptions, confidentialApproveMutationOptions, confidentialBalanceQueryOptions, confidentialBalancesQueryOptions, confidentialHandleQueryOptions, confidentialHandlesQueryOptions, confidentialIsApprovedQueryOptions, confidentialTransferFromMutationOptions, confidentialTransferMutationOptions, encryptMutationOptions, feeRecipientQueryOptions, filterQueryOptions, finalizeUnwrapMutationOptions, hashFn, isAllowedQueryOptions, isConfidentialQueryOptions, isWrapperQueryOptions, publicKeyQueryOptions, publicParamsQueryOptions, resumeUnshieldMutationOptions, revokeMutationOptions, revokeSessionMutationOptions, shieldETHMutationOptions, shieldFeeQueryOptions, shieldMutationOptions, signerAddressQueryOptions, tokenMetadataQueryOptions, totalSupplyQueryOptions, underlyingAllowanceQueryOptions, unshieldAllMutationOptions, unshieldFeeQueryOptions, unshieldMutationOptions, unwrapAllMutationOptions, unwrapMutationOptions, wrapperDiscoveryQueryOptions, zamaQueryKeys } from '@zama-fhe/sdk/query';
1
+ "use client";
12
2
 
3
+ import * as _zama_fhe_sdk0 from "@zama-fhe/sdk";
4
+ import { ActivityAmount, ActivityDirection, ActivityItem, ActivityItem as ActivityItem$1, ActivityLogMetadata, ActivityLogMetadata as ActivityLogMetadata$1, ActivityType, Address, Address as Address$1, ApprovalFailedError, ApproveSubmittedEvent, ApproveUnderlyingSubmittedEvent, BATCH_SWAP_ABI, BaseEvent, BatchDecryptOptions, BatchTransferData, ChromeSessionStorage, ClearValueType, ClearValueType as ClearValueType$1, ConfidentialTransferEvent, ContractAbi, CredentialsAllowedEvent, CredentialsCachedEvent, CredentialsCreatedEvent, CredentialsCreatingEvent, CredentialsExpiredEvent, CredentialsLoadingEvent, CredentialsManager, CredentialsManagerConfig, CredentialsRevokedEvent, DEPLOYMENT_COORDINATOR_ABI, DecryptEndEvent, DecryptErrorEvent, DecryptStartEvent, DecryptionFailedError, DelegatedUserDecryptParams, DelegatedUserDecryptParams as DelegatedUserDecryptParams$1, EIP712TypedData, EIP712TypedData as EIP712TypedData$1, ENCRYPTION_ABI, ERC165_ABI, ERC20_ABI, ERC20_METADATA_ABI, ERC7984_INTERFACE_ID, ERC7984_WRAPPER_INTERFACE_ID, EncryptEndEvent, EncryptErrorEvent, EncryptInput, EncryptParams, EncryptParams as EncryptParams$1, EncryptResult, EncryptResult as EncryptResult$1, EncryptStartEvent, EncryptionFailedError, FEE_MANAGER_ABI, FheTypeName, FhevmInstanceConfig, FinalizeUnwrapSubmittedEvent, GenericSigner, GenericSigner as GenericSigner$1, GenericStorage, GenericStorage as GenericStorage$1, Handle, Handle as Handle$1, HardhatConfig, Hex, Hex as Hex$1, IndexedDBStorage, InputProofBytesType, InvalidKeypairError, KeypairExpiredError, KeypairType, KeypairType as KeypairType$1, KmsDelegatedUserDecryptEIP712Type, MainnetConfig, MemoryStorage, NetworkType, NoCiphertextError, OnChainEvent, PublicDecryptResult, PublicDecryptResult as PublicDecryptResult$1, RawLog, RawLog as RawLog$1, ReadContractArgs, ReadContractConfig, ReadContractReturnType, ReadFunctionName, ReadonlyToken, ReadonlyTokenConfig, RelayerRequestFailedError, RelayerSDK, RelayerSDK as RelayerSDK$1, RelayerSDKStatus, RelayerWeb, RelayerWebConfig, RelayerWebSecurityConfig, SepoliaConfig, SessionExpiredEvent, ShieldCallbacks, ShieldSubmittedEvent, SigningFailedError, SigningRejectedError, StoredCredentials, TOKEN_TOPICS, TRANSFER_BATCHER_ABI, Token, TokenConfig, Topics, TransactionErrorEvent, TransactionReceipt, TransactionResult, TransactionResult as TransactionResult$1, TransactionRevertedError, TransferCallbacks, TransferFromSubmittedEvent, TransferSubmittedEvent, UnshieldCallbacks, UnshieldPhase1SubmittedEvent, UnshieldPhase2StartedEvent, UnshieldPhase2SubmittedEvent, UnwrapRequestedEvent, UnwrapSubmittedEvent, UnwrappedFinalizedEvent, UnwrappedStartedEvent, UserDecryptParams, UserDecryptParams as UserDecryptParams$1, WRAPPER_ABI, WrappedEvent, 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, decodeConfidentialTransfer, decodeOnChainEvent, decodeOnChainEvents, decodeUnwrapRequested, decodeUnwrappedFinalized, decodeUnwrappedStarted, decodeWrapped, deploymentCoordinatorContract, extractEncryptedHandles, finalizeUnwrapContract, findUnwrapRequested, findWrapped, getBatchTransferFeeContract, getFeeRecipientContract, getUnwrapFeeContract, getWrapFeeContract, getWrapperContract, indexedDBStorage, isConfidentialTokenContract, isConfidentialWrapperContract, isFinalizeUnwrapOperatorContract, isOperatorContract, loadPendingUnshield, matchZamaError, nameContract, parseActivityFeed, rateContract, savePendingUnshield, setFinalizeUnwrapOperatorContract, setOperatorContract, sortByBlockNumber, supportsInterfaceContract, symbolContract, totalSupplyContract, underlyingContract, unwrapContract, unwrapFromBalanceContract, wrapContract, wrapETHContract, wrapperExistsContract } from "@zama-fhe/sdk";
5
+ import { ApproveUnderlyingParams, ApproveUnderlyingParams as ApproveUnderlyingParams$1, ConfidentialApproveParams, ConfidentialApproveParams as ConfidentialApproveParams$1, ConfidentialBalancesData, ConfidentialBalancesData as ConfidentialBalancesData$1, ConfidentialTransferFromParams, ConfidentialTransferFromParams as ConfidentialTransferFromParams$1, ConfidentialTransferParams, ConfidentialTransferParams as ConfidentialTransferParams$1, FinalizeUnwrapParams, FinalizeUnwrapParams as FinalizeUnwrapParams$1, ResumeUnshieldParams, ResumeUnshieldParams as ResumeUnshieldParams$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, activityFeedQueryOptions, allowMutationOptions, approveUnderlyingMutationOptions, batchTransferFeeQueryOptions, confidentialApproveMutationOptions, confidentialBalanceQueryOptions, confidentialBalancesQueryOptions, confidentialHandleQueryOptions, confidentialHandlesQueryOptions, confidentialIsApprovedQueryOptions, confidentialTransferFromMutationOptions, confidentialTransferMutationOptions, encryptMutationOptions, feeRecipientQueryOptions, filterQueryOptions, finalizeUnwrapMutationOptions, hashFn, isAllowedQueryOptions, isConfidentialQueryOptions, isWrapperQueryOptions, publicKeyQueryOptions, publicParamsQueryOptions, resumeUnshieldMutationOptions, revokeMutationOptions, revokeSessionMutationOptions, shieldETHMutationOptions, shieldFeeQueryOptions, shieldMutationOptions, signerAddressQueryOptions, tokenMetadataQueryOptions, totalSupplyQueryOptions, underlyingAllowanceQueryOptions, unshieldAllMutationOptions, unshieldFeeQueryOptions, unshieldMutationOptions, unwrapAllMutationOptions, unwrapMutationOptions, wrapperDiscoveryQueryOptions, zamaQueryKeys } from "@zama-fhe/sdk/query";
6
+ import * as _tanstack_react_query0 from "@tanstack/react-query";
7
+ import { QueryKey, UseMutationOptions, UseQueryOptions } from "@tanstack/react-query";
8
+ import { PropsWithChildren } from "react";
9
+ import * as react_jsx_runtime0 from "react/jsx-runtime";
10
+ import * as _zama_fhe_relayer_sdk_web0 from "@zama-fhe/relayer-sdk/web";
11
+ import * as _tanstack_query_core0 from "@tanstack/query-core";
12
+
13
+ //#region src/provider.d.ts
13
14
  /** Props for {@link ZamaProvider}. */
14
15
  interface ZamaProviderProps extends PropsWithChildren {
15
- /** FHE relayer backend (RelayerWeb for browser, RelayerNode for server). */
16
- relayer: RelayerSDK;
17
- /** Wallet signer (`ViemSigner`, `EthersSigner`, or custom {@link GenericSigner}). */
18
- signer: GenericSigner;
19
- /** Credential storage backend (IndexedDBStorage for browser, MemoryStorage for tests). */
20
- storage: GenericStorage;
21
- /**
22
- * Session storage for wallet signatures. Defaults to in-memory (lost on reload).
23
- * Pass a `chrome.storage.session`-backed store for web extensions.
24
- */
25
- sessionStorage?: GenericStorage;
26
- /**
27
- * How long the ML-KEM re-encryption keypair remains valid, in seconds.
28
- * Default: `86400` (1 day). Must be positive — `0` is rejected.
29
- */
30
- keypairTTL?: number;
31
- /**
32
- * Controls how long session signatures (EIP-712 wallet signatures) remain valid, in seconds.
33
- * Default: `2592000` (30 days).
34
- * - `0`: never persist — every operation triggers a signing prompt (high-security mode).
35
- * - Positive number: seconds until the session signature expires and requires re-authentication.
36
- */
37
- sessionTTL?: number;
38
- /** Callback invoked on SDK lifecycle events. */
39
- onEvent?: ZamaSDKEventListener;
16
+ /** FHE relayer backend (RelayerWeb for browser, RelayerNode for server). */
17
+ relayer: RelayerSDK$1;
18
+ /** Wallet signer (`ViemSigner`, `EthersSigner`, or custom {@link GenericSigner}). */
19
+ signer: GenericSigner$1;
20
+ /** Credential storage backend (IndexedDBStorage for browser, MemoryStorage for tests). */
21
+ storage: GenericStorage$1;
22
+ /**
23
+ * Session storage for wallet signatures. Defaults to in-memory (lost on reload).
24
+ * Pass a `chrome.storage.session`-backed store for web extensions.
25
+ */
26
+ sessionStorage?: GenericStorage$1;
27
+ /**
28
+ * How long the ML-KEM re-encryption keypair remains valid, in seconds.
29
+ * Default: `86400` (1 day). Must be positive — `0` is rejected.
30
+ */
31
+ keypairTTL?: number;
32
+ /**
33
+ * Controls how long session signatures (EIP-712 wallet signatures) remain valid, in seconds.
34
+ * Default: `2592000` (30 days).
35
+ * - `0`: never persist — every operation triggers a signing prompt (high-security mode).
36
+ * - Positive number: seconds until the session signature expires and requires re-authentication.
37
+ */
38
+ sessionTTL?: number;
39
+ /** Callback invoked on SDK lifecycle events. */
40
+ onEvent?: ZamaSDKEventListener$1;
40
41
  }
41
42
  /**
42
43
  * Provides a {@link ZamaSDK} instance to all descendant hooks.
@@ -48,7 +49,16 @@ interface ZamaProviderProps extends PropsWithChildren {
48
49
  * </ZamaProvider>
49
50
  * ```
50
51
  */
51
- declare function ZamaProvider({ children, relayer, signer, storage, sessionStorage, keypairTTL, sessionTTL, onEvent, }: ZamaProviderProps): react_jsx_runtime.JSX.Element;
52
+ declare function ZamaProvider({
53
+ children,
54
+ relayer,
55
+ signer,
56
+ storage,
57
+ sessionStorage,
58
+ keypairTTL,
59
+ sessionTTL,
60
+ onEvent
61
+ }: ZamaProviderProps): react_jsx_runtime0.JSX.Element;
52
62
  /**
53
63
  * Access the {@link ZamaSDK} instance from context.
54
64
  * Throws if called outside a {@link ZamaProvider} or when no signer is provided.
@@ -59,8 +69,9 @@ declare function ZamaProvider({ children, relayer, signer, storage, sessionStora
59
69
  * const token = sdk.createReadonlyToken("0x...");
60
70
  * ```
61
71
  */
62
- declare function useZamaSDK(): ZamaSDK;
63
-
72
+ declare function useZamaSDK(): ZamaSDK$1;
73
+ //#endregion
74
+ //#region src/relayer/use-encrypt.d.ts
64
75
  /**
65
76
  * Encrypt a plaintext value using FHE.
66
77
  * Calls the relayer's `encrypt` method via a mutation.
@@ -73,8 +84,9 @@ declare function useZamaSDK(): ZamaSDK;
73
84
  * encrypt.mutate({ values: [1000n], bits: [64] });
74
85
  * ```
75
86
  */
76
- declare function useEncrypt(): _tanstack_react_query.UseMutationResult<EncryptResult, Error, EncryptParams, unknown>;
77
-
87
+ declare function useEncrypt(): _tanstack_react_query0.UseMutationResult<EncryptResult$1, Error, EncryptParams$1, unknown>;
88
+ //#endregion
89
+ //#region src/relayer/use-user-decrypt.d.ts
78
90
  /**
79
91
  * Thin wrapper around sdk.userDecrypt().
80
92
  * Caller is responsible for providing all params (keypair, signature, etc.).
@@ -84,8 +96,9 @@ declare function useEncrypt(): _tanstack_react_query.UseMutationResult<EncryptRe
84
96
  * On success, populates the decryption cache so useUserDecryptedValue/useUserDecryptedValues
85
97
  * can read the results.
86
98
  */
87
- declare function useUserDecrypt(): _tanstack_react_query.UseMutationResult<Record<`0x${string}`, ClearValueType>, Error, UserDecryptParams, unknown>;
88
-
99
+ declare function useUserDecrypt(): _tanstack_react_query0.UseMutationResult<Record<`0x${string}`, ClearValueType$1>, Error, UserDecryptParams$1, unknown>;
100
+ //#endregion
101
+ //#region src/relayer/use-public-decrypt.d.ts
89
102
  /**
90
103
  * Decrypt FHE ciphertext handles using the network public key (no credential needed).
91
104
  * On success, populates the decryption cache so {@link useUserDecryptedValue} / {@link useUserDecryptedValues}
@@ -100,8 +113,9 @@ declare function useUserDecrypt(): _tanstack_react_query.UseMutationResult<Recor
100
113
  * // publicDecrypt.data?.clearValues => { "0xHandle1": 500n, ... }
101
114
  * ```
102
115
  */
103
- declare function usePublicDecrypt(): _tanstack_react_query.UseMutationResult<PublicDecryptResult, Error, `0x${string}`[], unknown>;
104
-
116
+ declare function usePublicDecrypt(): _tanstack_react_query0.UseMutationResult<PublicDecryptResult$1, Error, `0x${string}`[], unknown>;
117
+ //#endregion
118
+ //#region src/relayer/use-generate-keypair.d.ts
105
119
  /**
106
120
  * Generate an FHE keypair via the relayer.
107
121
  * Returns a public/private key pair for use in decrypt authorization.
@@ -115,18 +129,19 @@ declare function usePublicDecrypt(): _tanstack_react_query.UseMutationResult<Pub
115
129
  * // generateKeypair.data?.publicKey, generateKeypair.data?.privateKey
116
130
  * ```
117
131
  */
118
- declare function useGenerateKeypair(): _tanstack_react_query.UseMutationResult<KeypairType<string>, Error, void, unknown>;
119
-
132
+ declare function useGenerateKeypair(): _tanstack_react_query0.UseMutationResult<KeypairType$1<string>, Error, void, unknown>;
133
+ //#endregion
134
+ //#region src/relayer/use-create-eip712.d.ts
120
135
  /** Parameters for {@link useCreateEIP712}. */
121
136
  interface CreateEIP712Params {
122
- /** The FHE public key (hex-encoded). */
123
- publicKey: string;
124
- /** Contract addresses the credential authorizes decryption for. */
125
- contractAddresses: `0x${string}`[];
126
- /** Unix timestamp (seconds) when the credential becomes valid. */
127
- startTimestamp: number;
128
- /** Number of days the credential remains valid. Default: 1. */
129
- durationDays?: number;
137
+ /** The FHE public key (hex-encoded). */
138
+ publicKey: string;
139
+ /** Contract addresses the credential authorizes decryption for. */
140
+ contractAddresses: `0x${string}`[];
141
+ /** Unix timestamp (seconds) when the credential becomes valid. */
142
+ startTimestamp: number;
143
+ /** Number of days the credential remains valid. Default: 1. */
144
+ durationDays?: number;
130
145
  }
131
146
  /**
132
147
  * Create EIP-712 typed data for signing an FHE decrypt credential.
@@ -144,20 +159,21 @@ interface CreateEIP712Params {
144
159
  * });
145
160
  * ```
146
161
  */
147
- declare function useCreateEIP712(): _tanstack_react_query.UseMutationResult<EIP712TypedData, Error, CreateEIP712Params, unknown>;
148
-
162
+ declare function useCreateEIP712(): _tanstack_react_query0.UseMutationResult<EIP712TypedData$1, Error, CreateEIP712Params, unknown>;
163
+ //#endregion
164
+ //#region src/relayer/use-create-delegated-user-decrypt-eip712.d.ts
149
165
  /** Parameters for {@link useCreateDelegatedUserDecryptEIP712}. */
150
166
  interface CreateDelegatedUserDecryptEIP712Params {
151
- /** The FHE public key (hex-encoded). */
152
- publicKey: string;
153
- /** Contract addresses the credential authorizes decryption for. */
154
- contractAddresses: Address[];
155
- /** Address of the wallet that delegated decrypt authority. */
156
- delegatorAddress: string;
157
- /** Unix timestamp (seconds) when the credential becomes valid. */
158
- startTimestamp: number;
159
- /** Number of days the credential remains valid. Default: 1. */
160
- durationDays?: number;
167
+ /** The FHE public key (hex-encoded). */
168
+ publicKey: string;
169
+ /** Contract addresses the credential authorizes decryption for. */
170
+ contractAddresses: Address$1[];
171
+ /** Address of the wallet that delegated decrypt authority. */
172
+ delegatorAddress: string;
173
+ /** Unix timestamp (seconds) when the credential becomes valid. */
174
+ startTimestamp: number;
175
+ /** Number of days the credential remains valid. Default: 1. */
176
+ durationDays?: number;
161
177
  }
162
178
  /**
163
179
  * Create EIP-712 typed data for a delegated user decrypt credential.
@@ -176,13 +192,14 @@ interface CreateDelegatedUserDecryptEIP712Params {
176
192
  * });
177
193
  * ```
178
194
  */
179
- declare function useCreateDelegatedUserDecryptEIP712(): _tanstack_react_query.UseMutationResult<Readonly<{
180
- types: _zama_fhe_relayer_sdk_web.KmsDelegatedUserDecryptEIP712TypesType;
181
- primaryType: "DelegatedUserDecryptRequestVerification";
182
- domain: _zama_fhe_relayer_sdk_web.KmsEIP712DomainType;
183
- message: _zama_fhe_relayer_sdk_web.KmsDelegatedUserDecryptEIP712MessageType;
195
+ declare function useCreateDelegatedUserDecryptEIP712(): _tanstack_react_query0.UseMutationResult<Readonly<{
196
+ types: _zama_fhe_relayer_sdk_web0.KmsDelegatedUserDecryptEIP712TypesType;
197
+ primaryType: "DelegatedUserDecryptRequestVerification";
198
+ domain: _zama_fhe_relayer_sdk_web0.KmsEIP712DomainType;
199
+ message: _zama_fhe_relayer_sdk_web0.KmsDelegatedUserDecryptEIP712MessageType;
184
200
  }>, Error, CreateDelegatedUserDecryptEIP712Params, unknown>;
185
-
201
+ //#endregion
202
+ //#region src/relayer/use-delegated-user-decrypt.d.ts
186
203
  /**
187
204
  * Decrypt FHE ciphertext handles using delegated user credentials.
188
205
  * Returns a map of handle → plaintext bigint.
@@ -196,8 +213,9 @@ declare function useCreateDelegatedUserDecryptEIP712(): _tanstack_react_query.Us
196
213
  * // decrypt.data => { "0xHandle1": 1000n }
197
214
  * ```
198
215
  */
199
- declare function useDelegatedUserDecrypt(): _tanstack_react_query.UseMutationResult<Record<`0x${string}`, ClearValueType>, Error, DelegatedUserDecryptParams, unknown>;
200
-
216
+ declare function useDelegatedUserDecrypt(): _tanstack_react_query0.UseMutationResult<Record<`0x${string}`, ClearValueType$1>, Error, DelegatedUserDecryptParams$1, unknown>;
217
+ //#endregion
218
+ //#region src/relayer/use-request-zk-proof-verification.d.ts
201
219
  /**
202
220
  * Submit a ZK proof for on-chain verification.
203
221
  * Returns the input proof bytes for use in contract calls.
@@ -211,17 +229,18 @@ declare function useDelegatedUserDecrypt(): _tanstack_react_query.UseMutationRes
211
229
  * // verify.data => Uint8Array (input proof bytes)
212
230
  * ```
213
231
  */
214
- declare function useRequestZKProofVerification(): _tanstack_react_query.UseMutationResult<Readonly<{
215
- handles: Uint8Array[];
216
- inputProof: Uint8Array;
217
- }>, Error, ZKProofLike, unknown>;
218
-
232
+ declare function useRequestZKProofVerification(): _tanstack_react_query0.UseMutationResult<Readonly<{
233
+ handles: Uint8Array[];
234
+ inputProof: Uint8Array;
235
+ }>, Error, ZKProofLike$1, unknown>;
236
+ //#endregion
237
+ //#region src/relayer/use-public-key.d.ts
219
238
  /** Shape of the FHE public key data returned by the relayer. */
220
239
  interface PublicKeyData {
221
- /** Unique identifier for this public key version. */
222
- publicKeyId: string;
223
- /** The raw FHE public key bytes. */
224
- publicKey: Uint8Array;
240
+ /** Unique identifier for this public key version. */
241
+ publicKeyId: string;
242
+ /** The raw FHE public key bytes. */
243
+ publicKey: Uint8Array;
225
244
  }
226
245
  /**
227
246
  * Fetch the FHE network public key from the relayer.
@@ -235,17 +254,18 @@ interface PublicKeyData {
235
254
  * // publicKey?.publicKeyId, publicKey?.publicKey
236
255
  * ```
237
256
  */
238
- declare function usePublicKey(): _tanstack_react_query.UseQueryResult<{
239
- publicKeyId: string;
240
- publicKey: Uint8Array;
257
+ declare function usePublicKey(): _tanstack_react_query0.UseQueryResult<{
258
+ publicKeyId: string;
259
+ publicKey: Uint8Array;
241
260
  } | null, Error>;
242
-
261
+ //#endregion
262
+ //#region src/relayer/use-public-params.d.ts
243
263
  /** Shape of the FHE public parameters returned by the relayer. */
244
264
  interface PublicParamsData {
245
- /** The raw public parameters bytes (WASM-ready). */
246
- publicParams: Uint8Array;
247
- /** Unique identifier for this public params version. */
248
- publicParamsId: string;
265
+ /** The raw public parameters bytes (WASM-ready). */
266
+ publicParams: Uint8Array;
267
+ /** Unique identifier for this public params version. */
268
+ publicParamsId: string;
249
269
  }
250
270
  /**
251
271
  * Fetch FHE public parameters for a given bit size from the relayer.
@@ -260,38 +280,39 @@ interface PublicParamsData {
260
280
  * // params?.publicParams, params?.publicParamsId
261
281
  * ```
262
282
  */
263
- declare function usePublicParams(bits: number): _tanstack_react_query.UseQueryResult<{
264
- publicParams: Uint8Array;
265
- publicParamsId: string;
283
+ declare function usePublicParams(bits: number): _tanstack_react_query0.UseQueryResult<{
284
+ publicParams: Uint8Array;
285
+ publicParamsId: string;
266
286
  } | null, Error>;
267
-
287
+ //#endregion
288
+ //#region src/relayer/use-user-decrypt-flow.d.ts
268
289
  /** A handle to decrypt, paired with its originating contract address. */
269
290
  interface DecryptHandle {
270
- handle: Handle;
271
- contractAddress: Address;
291
+ handle: Handle$1;
292
+ contractAddress: Address$1;
272
293
  }
273
294
  /** Parameters for {@link useUserDecryptFlow}. */
274
295
  interface UserDecryptFlowParams {
275
- /** Encrypted handles to decrypt. */
276
- handles: DecryptHandle[];
277
- /** Number of days the credential remains valid. Default: 1. */
278
- durationDays?: number;
296
+ /** Encrypted handles to decrypt. */
297
+ handles: DecryptHandle[];
298
+ /** Number of days the credential remains valid. Default: 1. */
299
+ durationDays?: number;
279
300
  }
280
301
  /** Progress callbacks for each step of the decrypt flow. */
281
302
  interface UserDecryptFlowCallbacks {
282
- /** Fired after the keypair is generated. */
283
- onKeypairGenerated?: () => void;
284
- /** Fired after the EIP-712 typed data is created, before wallet signing. */
285
- onEIP712Created?: () => void;
286
- /** Fired after the wallet signature is obtained. */
287
- onSigned?: (signature: Hex) => void;
288
- /** Fired after decryption completes. */
289
- onDecrypted?: (values: Record<Handle, ClearValueType>) => void;
303
+ /** Fired after the keypair is generated. */
304
+ onKeypairGenerated?: () => void;
305
+ /** Fired after the EIP-712 typed data is created, before wallet signing. */
306
+ onEIP712Created?: () => void;
307
+ /** Fired after the wallet signature is obtained. */
308
+ onSigned?: (signature: Hex$1) => void;
309
+ /** Fired after decryption completes. */
310
+ onDecrypted?: (values: Record<Handle$1, ClearValueType$1>) => void;
290
311
  }
291
312
  /** Configuration for {@link useUserDecryptFlow}. */
292
313
  interface UseUserDecryptFlowConfig {
293
- /** Optional progress callbacks. */
294
- callbacks?: UserDecryptFlowCallbacks;
314
+ /** Optional progress callbacks. */
315
+ callbacks?: UserDecryptFlowCallbacks;
295
316
  }
296
317
  /**
297
318
  * High-level orchestration hook for user decryption.
@@ -314,42 +335,46 @@ interface UseUserDecryptFlowConfig {
314
335
  * });
315
336
  * ```
316
337
  */
317
- declare function useUserDecryptFlow(config?: UseUserDecryptFlowConfig): _tanstack_react_query.UseMutationResult<Record<`0x${string}`, ClearValueType>, Error, UserDecryptFlowParams, unknown>;
318
-
338
+ declare function useUserDecryptFlow(config?: UseUserDecryptFlowConfig): _tanstack_react_query0.UseMutationResult<Record<`0x${string}`, ClearValueType$1>, Error, UserDecryptFlowParams, unknown>;
339
+ //#endregion
340
+ //#region src/relayer/use-user-decrypted-value.d.ts
319
341
  /**
320
342
  * Look up a single cached decrypted value by its handle.
321
343
  * Values are populated automatically when useUserDecrypt or usePublicDecrypt succeed.
322
344
  * You can also populate manually via queryClient.setQueryData(decryptionKeys.value(handle), value).
323
345
  */
324
- declare function useUserDecryptedValue(handle: Handle | undefined): _tanstack_react_query.UseQueryResult<ClearValueType, Error>;
325
-
346
+ declare function useUserDecryptedValue(handle: Handle$1 | undefined): _tanstack_react_query0.UseQueryResult<ClearValueType$1, Error>;
347
+ //#endregion
348
+ //#region src/relayer/use-user-decrypted-values.d.ts
326
349
  /**
327
350
  * Look up multiple cached decrypted values by their handles.
328
351
  * Values are populated automatically when useUserDecrypt or usePublicDecrypt succeed.
329
352
  */
330
- declare function useUserDecryptedValues(handles: Handle[]): {
331
- data: Partial<Record<`0x${string}`, ClearValueType | undefined>>;
332
- results: _tanstack_react_query.UseQueryResult<never, Error>[];
353
+ declare function useUserDecryptedValues(handles: Handle$1[]): {
354
+ data: Partial<Record<`0x${string}`, ClearValueType$1 | undefined>>;
355
+ results: _tanstack_react_query0.UseQueryResult<never, Error>[];
333
356
  };
334
-
357
+ //#endregion
358
+ //#region src/relayer/decryption-cache.d.ts
335
359
  /**
336
360
  * Query key helpers for the shared decryption cache.
337
361
  * Used by useUserDecrypt/usePublicDecrypt to populate,
338
362
  * and by useUserDecryptedValue to read.
339
363
  */
340
364
  declare const decryptionKeys: {
341
- value: (handle: string, contractAddress?: string) => readonly ["zama.decryption", {
342
- readonly contractAddress?: `0x${string}` | undefined;
343
- readonly handle: string;
344
- }];
365
+ value: (handle: string, contractAddress?: string) => readonly ["zama.decryption", {
366
+ readonly contractAddress?: `0x${string}` | undefined;
367
+ readonly handle: string;
368
+ }];
345
369
  };
346
-
370
+ //#endregion
371
+ //#region src/token/use-token.d.ts
347
372
  /** Base configuration shared by all mutation hooks that need a Token instance. */
348
373
  interface UseZamaConfig {
349
- /** Address of the confidential token contract. */
350
- tokenAddress: Address;
351
- /** Address of the wrapper contract (required for shield/unshield operations). */
352
- wrapperAddress?: Address;
374
+ /** Address of the confidential token contract. */
375
+ tokenAddress: Address$1;
376
+ /** Address of the wrapper contract (required for shield/unshield operations). */
377
+ wrapperAddress?: Address$1;
353
378
  }
354
379
  /**
355
380
  * Get a {@link Token} instance, memoized by address pair.
@@ -363,8 +388,9 @@ interface UseZamaConfig {
363
388
  * const token = useToken({ tokenAddress: "0xToken", wrapperAddress: "0xWrapper" });
364
389
  * ```
365
390
  */
366
- declare function useToken(config: UseZamaConfig): _zama_fhe_sdk.Token;
367
-
391
+ declare function useToken(config: UseZamaConfig): _zama_fhe_sdk0.Token;
392
+ //#endregion
393
+ //#region src/token/use-readonly-token.d.ts
368
394
  /**
369
395
  * Get a {@link ReadonlyToken} instance, memoized by address.
370
396
  * Supports balance queries, ERC-165 checks, and authorization — no wrapper needed.
@@ -379,14 +405,15 @@ declare function useToken(config: UseZamaConfig): _zama_fhe_sdk.Token;
379
405
  * // token.balanceOf(), token.isConfidential(), etc.
380
406
  * ```
381
407
  */
382
- declare function useReadonlyToken(address: Address): _zama_fhe_sdk.ReadonlyToken;
383
-
408
+ declare function useReadonlyToken(address: Address$1): _zama_fhe_sdk0.ReadonlyToken;
409
+ //#endregion
410
+ //#region src/token/use-confidential-balance.d.ts
384
411
  /** Configuration for {@link useConfidentialBalance}. */
385
412
  interface UseConfidentialBalanceConfig {
386
- /** Address of the confidential token contract. */
387
- tokenAddress: Address;
388
- /** Polling interval (ms) for the encrypted handle. Default: 10 000. */
389
- handleRefetchInterval?: number;
413
+ /** Address of the confidential token contract. */
414
+ tokenAddress: Address$1;
415
+ /** Polling interval (ms) for the encrypted handle. Default: 10 000. */
416
+ handleRefetchInterval?: number;
390
417
  }
391
418
  /** Query options for the decrypt phase of {@link useConfidentialBalance}. */
392
419
  type UseConfidentialBalanceOptions = Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">;
@@ -407,187 +434,187 @@ type UseConfidentialBalanceOptions = Omit<UseQueryOptions<bigint, Error>, "query
407
434
  * ```
408
435
  */
409
436
  declare function useConfidentialBalance(config: UseConfidentialBalanceConfig, options?: UseConfidentialBalanceOptions): {
410
- handleQuery: _tanstack_react_query.UseQueryResult<`0x${string}`, Error>;
411
- data: bigint;
412
- error: Error;
413
- isError: true;
414
- isPending: false;
415
- isLoading: false;
416
- isLoadingError: false;
417
- isRefetchError: true;
418
- isSuccess: false;
419
- isPlaceholderData: false;
420
- status: "error";
421
- dataUpdatedAt: number;
422
- errorUpdatedAt: number;
423
- failureCount: number;
424
- failureReason: Error | null;
425
- errorUpdateCount: number;
426
- isFetched: boolean;
427
- isFetchedAfterMount: boolean;
428
- isFetching: boolean;
429
- isInitialLoading: boolean;
430
- isPaused: boolean;
431
- isRefetching: boolean;
432
- isStale: boolean;
433
- isEnabled: boolean;
434
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<bigint, Error>>;
435
- fetchStatus: _tanstack_query_core.FetchStatus;
436
- promise: Promise<bigint>;
437
+ handleQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`, Error>;
438
+ data: bigint;
439
+ error: Error;
440
+ isError: true;
441
+ isPending: false;
442
+ isLoading: false;
443
+ isLoadingError: false;
444
+ isRefetchError: true;
445
+ isSuccess: false;
446
+ isPlaceholderData: false;
447
+ status: "error";
448
+ dataUpdatedAt: number;
449
+ errorUpdatedAt: number;
450
+ failureCount: number;
451
+ failureReason: Error | null;
452
+ errorUpdateCount: number;
453
+ isFetched: boolean;
454
+ isFetchedAfterMount: boolean;
455
+ isFetching: boolean;
456
+ isInitialLoading: boolean;
457
+ isPaused: boolean;
458
+ isRefetching: boolean;
459
+ isStale: boolean;
460
+ isEnabled: boolean;
461
+ refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<bigint, Error>>;
462
+ fetchStatus: _tanstack_query_core0.FetchStatus;
463
+ promise: Promise<bigint>;
437
464
  } | {
438
- handleQuery: _tanstack_react_query.UseQueryResult<`0x${string}`, Error>;
439
- data: bigint;
440
- error: null;
441
- isError: false;
442
- isPending: false;
443
- isLoading: false;
444
- isLoadingError: false;
445
- isRefetchError: false;
446
- isSuccess: true;
447
- isPlaceholderData: false;
448
- status: "success";
449
- dataUpdatedAt: number;
450
- errorUpdatedAt: number;
451
- failureCount: number;
452
- failureReason: Error | null;
453
- errorUpdateCount: number;
454
- isFetched: boolean;
455
- isFetchedAfterMount: boolean;
456
- isFetching: boolean;
457
- isInitialLoading: boolean;
458
- isPaused: boolean;
459
- isRefetching: boolean;
460
- isStale: boolean;
461
- isEnabled: boolean;
462
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<bigint, Error>>;
463
- fetchStatus: _tanstack_query_core.FetchStatus;
464
- promise: Promise<bigint>;
465
+ handleQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`, Error>;
466
+ data: bigint;
467
+ error: null;
468
+ isError: false;
469
+ isPending: false;
470
+ isLoading: false;
471
+ isLoadingError: false;
472
+ isRefetchError: false;
473
+ isSuccess: true;
474
+ isPlaceholderData: false;
475
+ status: "success";
476
+ dataUpdatedAt: number;
477
+ errorUpdatedAt: number;
478
+ failureCount: number;
479
+ failureReason: Error | null;
480
+ errorUpdateCount: number;
481
+ isFetched: boolean;
482
+ isFetchedAfterMount: boolean;
483
+ isFetching: boolean;
484
+ isInitialLoading: boolean;
485
+ isPaused: boolean;
486
+ isRefetching: boolean;
487
+ isStale: boolean;
488
+ isEnabled: boolean;
489
+ refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<bigint, Error>>;
490
+ fetchStatus: _tanstack_query_core0.FetchStatus;
491
+ promise: Promise<bigint>;
465
492
  } | {
466
- handleQuery: _tanstack_react_query.UseQueryResult<`0x${string}`, Error>;
467
- data: undefined;
468
- error: Error;
469
- isError: true;
470
- isPending: false;
471
- isLoading: false;
472
- isLoadingError: true;
473
- isRefetchError: false;
474
- isSuccess: false;
475
- isPlaceholderData: false;
476
- status: "error";
477
- dataUpdatedAt: number;
478
- errorUpdatedAt: number;
479
- failureCount: number;
480
- failureReason: Error | null;
481
- errorUpdateCount: number;
482
- isFetched: boolean;
483
- isFetchedAfterMount: boolean;
484
- isFetching: boolean;
485
- isInitialLoading: boolean;
486
- isPaused: boolean;
487
- isRefetching: boolean;
488
- isStale: boolean;
489
- isEnabled: boolean;
490
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<bigint, Error>>;
491
- fetchStatus: _tanstack_query_core.FetchStatus;
492
- promise: Promise<bigint>;
493
+ handleQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`, Error>;
494
+ data: undefined;
495
+ error: Error;
496
+ isError: true;
497
+ isPending: false;
498
+ isLoading: false;
499
+ isLoadingError: true;
500
+ isRefetchError: false;
501
+ isSuccess: false;
502
+ isPlaceholderData: false;
503
+ status: "error";
504
+ dataUpdatedAt: number;
505
+ errorUpdatedAt: number;
506
+ failureCount: number;
507
+ failureReason: Error | null;
508
+ errorUpdateCount: number;
509
+ isFetched: boolean;
510
+ isFetchedAfterMount: boolean;
511
+ isFetching: boolean;
512
+ isInitialLoading: boolean;
513
+ isPaused: boolean;
514
+ isRefetching: boolean;
515
+ isStale: boolean;
516
+ isEnabled: boolean;
517
+ refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<bigint, Error>>;
518
+ fetchStatus: _tanstack_query_core0.FetchStatus;
519
+ promise: Promise<bigint>;
493
520
  } | {
494
- handleQuery: _tanstack_react_query.UseQueryResult<`0x${string}`, Error>;
495
- data: undefined;
496
- error: null;
497
- isError: false;
498
- isPending: true;
499
- isLoading: true;
500
- isLoadingError: false;
501
- isRefetchError: false;
502
- isSuccess: false;
503
- isPlaceholderData: false;
504
- status: "pending";
505
- dataUpdatedAt: number;
506
- errorUpdatedAt: number;
507
- failureCount: number;
508
- failureReason: Error | null;
509
- errorUpdateCount: number;
510
- isFetched: boolean;
511
- isFetchedAfterMount: boolean;
512
- isFetching: boolean;
513
- isInitialLoading: boolean;
514
- isPaused: boolean;
515
- isRefetching: boolean;
516
- isStale: boolean;
517
- isEnabled: boolean;
518
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<bigint, Error>>;
519
- fetchStatus: _tanstack_query_core.FetchStatus;
520
- promise: Promise<bigint>;
521
+ handleQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`, Error>;
522
+ data: undefined;
523
+ error: null;
524
+ isError: false;
525
+ isPending: true;
526
+ isLoading: true;
527
+ isLoadingError: false;
528
+ isRefetchError: false;
529
+ isSuccess: false;
530
+ isPlaceholderData: false;
531
+ status: "pending";
532
+ dataUpdatedAt: number;
533
+ errorUpdatedAt: number;
534
+ failureCount: number;
535
+ failureReason: Error | null;
536
+ errorUpdateCount: number;
537
+ isFetched: boolean;
538
+ isFetchedAfterMount: boolean;
539
+ isFetching: boolean;
540
+ isInitialLoading: boolean;
541
+ isPaused: boolean;
542
+ isRefetching: boolean;
543
+ isStale: boolean;
544
+ isEnabled: boolean;
545
+ refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<bigint, Error>>;
546
+ fetchStatus: _tanstack_query_core0.FetchStatus;
547
+ promise: Promise<bigint>;
521
548
  } | {
522
- handleQuery: _tanstack_react_query.UseQueryResult<`0x${string}`, Error>;
523
- data: undefined;
524
- error: null;
525
- isError: false;
526
- isPending: true;
527
- isLoadingError: false;
528
- isRefetchError: false;
529
- isSuccess: false;
530
- isPlaceholderData: false;
531
- status: "pending";
532
- dataUpdatedAt: number;
533
- errorUpdatedAt: number;
534
- failureCount: number;
535
- failureReason: Error | null;
536
- errorUpdateCount: number;
537
- isFetched: boolean;
538
- isFetchedAfterMount: boolean;
539
- isFetching: boolean;
540
- isLoading: boolean;
541
- isInitialLoading: boolean;
542
- isPaused: boolean;
543
- isRefetching: boolean;
544
- isStale: boolean;
545
- isEnabled: boolean;
546
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<bigint, Error>>;
547
- fetchStatus: _tanstack_query_core.FetchStatus;
548
- promise: Promise<bigint>;
549
+ handleQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`, Error>;
550
+ data: undefined;
551
+ error: null;
552
+ isError: false;
553
+ isPending: true;
554
+ isLoadingError: false;
555
+ isRefetchError: false;
556
+ isSuccess: false;
557
+ isPlaceholderData: false;
558
+ status: "pending";
559
+ dataUpdatedAt: number;
560
+ errorUpdatedAt: number;
561
+ failureCount: number;
562
+ failureReason: Error | null;
563
+ errorUpdateCount: number;
564
+ isFetched: boolean;
565
+ isFetchedAfterMount: boolean;
566
+ isFetching: boolean;
567
+ isLoading: boolean;
568
+ isInitialLoading: boolean;
569
+ isPaused: boolean;
570
+ isRefetching: boolean;
571
+ isStale: boolean;
572
+ isEnabled: boolean;
573
+ refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<bigint, Error>>;
574
+ fetchStatus: _tanstack_query_core0.FetchStatus;
575
+ promise: Promise<bigint>;
549
576
  } | {
550
- handleQuery: _tanstack_react_query.UseQueryResult<`0x${string}`, Error>;
551
- data: bigint;
552
- isError: false;
553
- error: null;
554
- isPending: false;
555
- isLoading: false;
556
- isLoadingError: false;
557
- isRefetchError: false;
558
- isSuccess: true;
559
- isPlaceholderData: true;
560
- status: "success";
561
- dataUpdatedAt: number;
562
- errorUpdatedAt: number;
563
- failureCount: number;
564
- failureReason: Error | null;
565
- errorUpdateCount: number;
566
- isFetched: boolean;
567
- isFetchedAfterMount: boolean;
568
- isFetching: boolean;
569
- isInitialLoading: boolean;
570
- isPaused: boolean;
571
- isRefetching: boolean;
572
- isStale: boolean;
573
- isEnabled: boolean;
574
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<bigint, Error>>;
575
- fetchStatus: _tanstack_query_core.FetchStatus;
576
- promise: Promise<bigint>;
577
+ handleQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`, Error>;
578
+ data: bigint;
579
+ isError: false;
580
+ error: null;
581
+ isPending: false;
582
+ isLoading: false;
583
+ isLoadingError: false;
584
+ isRefetchError: false;
585
+ isSuccess: true;
586
+ isPlaceholderData: true;
587
+ status: "success";
588
+ dataUpdatedAt: number;
589
+ errorUpdatedAt: number;
590
+ failureCount: number;
591
+ failureReason: Error | null;
592
+ errorUpdateCount: number;
593
+ isFetched: boolean;
594
+ isFetchedAfterMount: boolean;
595
+ isFetching: boolean;
596
+ isInitialLoading: boolean;
597
+ isPaused: boolean;
598
+ isRefetching: boolean;
599
+ isStale: boolean;
600
+ isEnabled: boolean;
601
+ refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<bigint, Error>>;
602
+ fetchStatus: _tanstack_query_core0.FetchStatus;
603
+ promise: Promise<bigint>;
577
604
  };
578
-
605
+ //#endregion
606
+ //#region src/token/use-confidential-balances.d.ts
579
607
  /** Configuration for {@link useConfidentialBalances}. */
580
608
  interface UseConfidentialBalancesConfig {
581
- /** Addresses of the confidential token contracts to batch-query. */
582
- tokenAddresses: Address[];
583
- /** Polling interval (ms) for the encrypted handles. Default: 10 000. */
584
- handleRefetchInterval?: number;
585
- /** Maximum number of concurrent decrypt calls. Default: `Infinity` (no limit). */
586
- maxConcurrency?: number;
609
+ /** Addresses of the confidential token contracts to batch-query. */
610
+ tokenAddresses: Address$1[];
611
+ /** Polling interval (ms) for the encrypted handles. Default: 10 000. */
612
+ handleRefetchInterval?: number;
613
+ /** Maximum number of concurrent decrypt calls. Default: `Infinity` (no limit). */
614
+ maxConcurrency?: number;
587
615
  }
588
-
589
616
  /** Query options for the decrypt phase of {@link useConfidentialBalances}. */
590
- type UseConfidentialBalancesOptions = Omit<UseQueryOptions<ConfidentialBalancesData, Error>, "queryKey" | "queryFn">;
617
+ type UseConfidentialBalancesOptions = Omit<UseQueryOptions<ConfidentialBalancesData$1, Error>, "queryKey" | "queryFn">;
591
618
  /**
592
619
  * Declarative hook to read multiple confidential token balances in batch.
593
620
  * Uses two-phase polling: cheaply polls encrypted handles, then only
@@ -612,175 +639,176 @@ type UseConfidentialBalancesOptions = Omit<UseQueryOptions<ConfidentialBalancesD
612
639
  * ```
613
640
  */
614
641
  declare function useConfidentialBalances(config: UseConfidentialBalancesConfig, options?: UseConfidentialBalancesOptions): {
615
- handlesQuery: _tanstack_react_query.UseQueryResult<`0x${string}`[], Error>;
616
- data: ConfidentialBalancesData;
617
- error: Error;
618
- isError: true;
619
- isPending: false;
620
- isLoading: false;
621
- isLoadingError: false;
622
- isRefetchError: true;
623
- isSuccess: false;
624
- isPlaceholderData: false;
625
- status: "error";
626
- dataUpdatedAt: number;
627
- errorUpdatedAt: number;
628
- failureCount: number;
629
- failureReason: Error | null;
630
- errorUpdateCount: number;
631
- isFetched: boolean;
632
- isFetchedAfterMount: boolean;
633
- isFetching: boolean;
634
- isInitialLoading: boolean;
635
- isPaused: boolean;
636
- isRefetching: boolean;
637
- isStale: boolean;
638
- isEnabled: boolean;
639
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<ConfidentialBalancesData, Error>>;
640
- fetchStatus: _tanstack_query_core.FetchStatus;
641
- promise: Promise<ConfidentialBalancesData>;
642
+ handlesQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`[], Error>;
643
+ data: ConfidentialBalancesData$1;
644
+ error: Error;
645
+ isError: true;
646
+ isPending: false;
647
+ isLoading: false;
648
+ isLoadingError: false;
649
+ isRefetchError: true;
650
+ isSuccess: false;
651
+ isPlaceholderData: false;
652
+ status: "error";
653
+ dataUpdatedAt: number;
654
+ errorUpdatedAt: number;
655
+ failureCount: number;
656
+ failureReason: Error | null;
657
+ errorUpdateCount: number;
658
+ isFetched: boolean;
659
+ isFetchedAfterMount: boolean;
660
+ isFetching: boolean;
661
+ isInitialLoading: boolean;
662
+ isPaused: boolean;
663
+ isRefetching: boolean;
664
+ isStale: boolean;
665
+ isEnabled: boolean;
666
+ refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<ConfidentialBalancesData$1, Error>>;
667
+ fetchStatus: _tanstack_query_core0.FetchStatus;
668
+ promise: Promise<ConfidentialBalancesData$1>;
642
669
  } | {
643
- handlesQuery: _tanstack_react_query.UseQueryResult<`0x${string}`[], Error>;
644
- data: ConfidentialBalancesData;
645
- error: null;
646
- isError: false;
647
- isPending: false;
648
- isLoading: false;
649
- isLoadingError: false;
650
- isRefetchError: false;
651
- isSuccess: true;
652
- isPlaceholderData: false;
653
- status: "success";
654
- dataUpdatedAt: number;
655
- errorUpdatedAt: number;
656
- failureCount: number;
657
- failureReason: Error | null;
658
- errorUpdateCount: number;
659
- isFetched: boolean;
660
- isFetchedAfterMount: boolean;
661
- isFetching: boolean;
662
- isInitialLoading: boolean;
663
- isPaused: boolean;
664
- isRefetching: boolean;
665
- isStale: boolean;
666
- isEnabled: boolean;
667
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<ConfidentialBalancesData, Error>>;
668
- fetchStatus: _tanstack_query_core.FetchStatus;
669
- promise: Promise<ConfidentialBalancesData>;
670
+ handlesQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`[], Error>;
671
+ data: ConfidentialBalancesData$1;
672
+ error: null;
673
+ isError: false;
674
+ isPending: false;
675
+ isLoading: false;
676
+ isLoadingError: false;
677
+ isRefetchError: false;
678
+ isSuccess: true;
679
+ isPlaceholderData: false;
680
+ status: "success";
681
+ dataUpdatedAt: number;
682
+ errorUpdatedAt: number;
683
+ failureCount: number;
684
+ failureReason: Error | null;
685
+ errorUpdateCount: number;
686
+ isFetched: boolean;
687
+ isFetchedAfterMount: boolean;
688
+ isFetching: boolean;
689
+ isInitialLoading: boolean;
690
+ isPaused: boolean;
691
+ isRefetching: boolean;
692
+ isStale: boolean;
693
+ isEnabled: boolean;
694
+ refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<ConfidentialBalancesData$1, Error>>;
695
+ fetchStatus: _tanstack_query_core0.FetchStatus;
696
+ promise: Promise<ConfidentialBalancesData$1>;
670
697
  } | {
671
- handlesQuery: _tanstack_react_query.UseQueryResult<`0x${string}`[], Error>;
672
- data: undefined;
673
- error: Error;
674
- isError: true;
675
- isPending: false;
676
- isLoading: false;
677
- isLoadingError: true;
678
- isRefetchError: false;
679
- isSuccess: false;
680
- isPlaceholderData: false;
681
- status: "error";
682
- dataUpdatedAt: number;
683
- errorUpdatedAt: number;
684
- failureCount: number;
685
- failureReason: Error | null;
686
- errorUpdateCount: number;
687
- isFetched: boolean;
688
- isFetchedAfterMount: boolean;
689
- isFetching: boolean;
690
- isInitialLoading: boolean;
691
- isPaused: boolean;
692
- isRefetching: boolean;
693
- isStale: boolean;
694
- isEnabled: boolean;
695
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<ConfidentialBalancesData, Error>>;
696
- fetchStatus: _tanstack_query_core.FetchStatus;
697
- promise: Promise<ConfidentialBalancesData>;
698
+ handlesQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`[], Error>;
699
+ data: undefined;
700
+ error: Error;
701
+ isError: true;
702
+ isPending: false;
703
+ isLoading: false;
704
+ isLoadingError: true;
705
+ isRefetchError: false;
706
+ isSuccess: false;
707
+ isPlaceholderData: false;
708
+ status: "error";
709
+ dataUpdatedAt: number;
710
+ errorUpdatedAt: number;
711
+ failureCount: number;
712
+ failureReason: Error | null;
713
+ errorUpdateCount: number;
714
+ isFetched: boolean;
715
+ isFetchedAfterMount: boolean;
716
+ isFetching: boolean;
717
+ isInitialLoading: boolean;
718
+ isPaused: boolean;
719
+ isRefetching: boolean;
720
+ isStale: boolean;
721
+ isEnabled: boolean;
722
+ refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<ConfidentialBalancesData$1, Error>>;
723
+ fetchStatus: _tanstack_query_core0.FetchStatus;
724
+ promise: Promise<ConfidentialBalancesData$1>;
698
725
  } | {
699
- handlesQuery: _tanstack_react_query.UseQueryResult<`0x${string}`[], Error>;
700
- data: undefined;
701
- error: null;
702
- isError: false;
703
- isPending: true;
704
- isLoading: true;
705
- isLoadingError: false;
706
- isRefetchError: false;
707
- isSuccess: false;
708
- isPlaceholderData: false;
709
- status: "pending";
710
- dataUpdatedAt: number;
711
- errorUpdatedAt: number;
712
- failureCount: number;
713
- failureReason: Error | null;
714
- errorUpdateCount: number;
715
- isFetched: boolean;
716
- isFetchedAfterMount: boolean;
717
- isFetching: boolean;
718
- isInitialLoading: boolean;
719
- isPaused: boolean;
720
- isRefetching: boolean;
721
- isStale: boolean;
722
- isEnabled: boolean;
723
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<ConfidentialBalancesData, Error>>;
724
- fetchStatus: _tanstack_query_core.FetchStatus;
725
- promise: Promise<ConfidentialBalancesData>;
726
+ handlesQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`[], Error>;
727
+ data: undefined;
728
+ error: null;
729
+ isError: false;
730
+ isPending: true;
731
+ isLoading: true;
732
+ isLoadingError: false;
733
+ isRefetchError: false;
734
+ isSuccess: false;
735
+ isPlaceholderData: false;
736
+ status: "pending";
737
+ dataUpdatedAt: number;
738
+ errorUpdatedAt: number;
739
+ failureCount: number;
740
+ failureReason: Error | null;
741
+ errorUpdateCount: number;
742
+ isFetched: boolean;
743
+ isFetchedAfterMount: boolean;
744
+ isFetching: boolean;
745
+ isInitialLoading: boolean;
746
+ isPaused: boolean;
747
+ isRefetching: boolean;
748
+ isStale: boolean;
749
+ isEnabled: boolean;
750
+ refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<ConfidentialBalancesData$1, Error>>;
751
+ fetchStatus: _tanstack_query_core0.FetchStatus;
752
+ promise: Promise<ConfidentialBalancesData$1>;
726
753
  } | {
727
- handlesQuery: _tanstack_react_query.UseQueryResult<`0x${string}`[], Error>;
728
- data: undefined;
729
- error: null;
730
- isError: false;
731
- isPending: true;
732
- isLoadingError: false;
733
- isRefetchError: false;
734
- isSuccess: false;
735
- isPlaceholderData: false;
736
- status: "pending";
737
- dataUpdatedAt: number;
738
- errorUpdatedAt: number;
739
- failureCount: number;
740
- failureReason: Error | null;
741
- errorUpdateCount: number;
742
- isFetched: boolean;
743
- isFetchedAfterMount: boolean;
744
- isFetching: boolean;
745
- isLoading: boolean;
746
- isInitialLoading: boolean;
747
- isPaused: boolean;
748
- isRefetching: boolean;
749
- isStale: boolean;
750
- isEnabled: boolean;
751
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<ConfidentialBalancesData, Error>>;
752
- fetchStatus: _tanstack_query_core.FetchStatus;
753
- promise: Promise<ConfidentialBalancesData>;
754
+ handlesQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`[], Error>;
755
+ data: undefined;
756
+ error: null;
757
+ isError: false;
758
+ isPending: true;
759
+ isLoadingError: false;
760
+ isRefetchError: false;
761
+ isSuccess: false;
762
+ isPlaceholderData: false;
763
+ status: "pending";
764
+ dataUpdatedAt: number;
765
+ errorUpdatedAt: number;
766
+ failureCount: number;
767
+ failureReason: Error | null;
768
+ errorUpdateCount: number;
769
+ isFetched: boolean;
770
+ isFetchedAfterMount: boolean;
771
+ isFetching: boolean;
772
+ isLoading: boolean;
773
+ isInitialLoading: boolean;
774
+ isPaused: boolean;
775
+ isRefetching: boolean;
776
+ isStale: boolean;
777
+ isEnabled: boolean;
778
+ refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<ConfidentialBalancesData$1, Error>>;
779
+ fetchStatus: _tanstack_query_core0.FetchStatus;
780
+ promise: Promise<ConfidentialBalancesData$1>;
754
781
  } | {
755
- handlesQuery: _tanstack_react_query.UseQueryResult<`0x${string}`[], Error>;
756
- data: ConfidentialBalancesData;
757
- isError: false;
758
- error: null;
759
- isPending: false;
760
- isLoading: false;
761
- isLoadingError: false;
762
- isRefetchError: false;
763
- isSuccess: true;
764
- isPlaceholderData: true;
765
- status: "success";
766
- dataUpdatedAt: number;
767
- errorUpdatedAt: number;
768
- failureCount: number;
769
- failureReason: Error | null;
770
- errorUpdateCount: number;
771
- isFetched: boolean;
772
- isFetchedAfterMount: boolean;
773
- isFetching: boolean;
774
- isInitialLoading: boolean;
775
- isPaused: boolean;
776
- isRefetching: boolean;
777
- isStale: boolean;
778
- isEnabled: boolean;
779
- refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<ConfidentialBalancesData, Error>>;
780
- fetchStatus: _tanstack_query_core.FetchStatus;
781
- promise: Promise<ConfidentialBalancesData>;
782
+ handlesQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`[], Error>;
783
+ data: ConfidentialBalancesData$1;
784
+ isError: false;
785
+ error: null;
786
+ isPending: false;
787
+ isLoading: false;
788
+ isLoadingError: false;
789
+ isRefetchError: false;
790
+ isSuccess: true;
791
+ isPlaceholderData: true;
792
+ status: "success";
793
+ dataUpdatedAt: number;
794
+ errorUpdatedAt: number;
795
+ failureCount: number;
796
+ failureReason: Error | null;
797
+ errorUpdateCount: number;
798
+ isFetched: boolean;
799
+ isFetchedAfterMount: boolean;
800
+ isFetching: boolean;
801
+ isInitialLoading: boolean;
802
+ isPaused: boolean;
803
+ isRefetching: boolean;
804
+ isStale: boolean;
805
+ isEnabled: boolean;
806
+ refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<ConfidentialBalancesData$1, Error>>;
807
+ fetchStatus: _tanstack_query_core0.FetchStatus;
808
+ promise: Promise<ConfidentialBalancesData$1>;
782
809
  };
783
-
810
+ //#endregion
811
+ //#region src/token/use-allow.d.ts
784
812
  /**
785
813
  * Pre-authorize FHE decrypt credentials for a list of token addresses.
786
814
  * A single wallet signature covers all addresses, so subsequent decrypt
@@ -792,8 +820,9 @@ declare function useConfidentialBalances(config: UseConfidentialBalancesConfig,
792
820
  * // Call allow(allTokenAddresses) before any individual reveal
793
821
  * ```
794
822
  */
795
- declare function useAllow(options?: UseMutationOptions<void, Error, Address[]>): _tanstack_react_query.UseMutationResult<void, Error, `0x${string}`[], unknown>;
796
-
823
+ declare function useAllow(options?: UseMutationOptions<void, Error, Address$1[]>): _tanstack_react_query0.UseMutationResult<void, Error, `0x${string}`[], unknown>;
824
+ //#endregion
825
+ //#region src/token/use-is-allowed.d.ts
797
826
  /**
798
827
  * Check whether a session signature is cached for the connected wallet.
799
828
  * Returns `true` if decrypt operations can proceed without a wallet prompt.
@@ -803,8 +832,9 @@ declare function useAllow(options?: UseMutationOptions<void, Error, Address[]>):
803
832
  * const { data: allowed } = useIsAllowed();
804
833
  * ```
805
834
  */
806
- declare function useIsAllowed(): _tanstack_react_query.UseQueryResult<unknown, Error>;
807
-
835
+ declare function useIsAllowed(): _tanstack_react_query0.UseQueryResult<unknown, Error>;
836
+ //#endregion
837
+ //#region src/token/use-revoke.d.ts
808
838
  /**
809
839
  * Revoke stored FHE credentials for a list of token addresses.
810
840
  * The next decrypt operation will require a fresh wallet signature.
@@ -815,8 +845,9 @@ declare function useIsAllowed(): _tanstack_react_query.UseQueryResult<unknown, E
815
845
  * revoke(["0xTokenA", "0xTokenB"]);
816
846
  * ```
817
847
  */
818
- declare function useRevoke(options?: UseMutationOptions<void, Error, Address[]>): _tanstack_react_query.UseMutationResult<void, Error, `0x${string}`[], unknown>;
819
-
848
+ declare function useRevoke(options?: UseMutationOptions<void, Error, Address$1[]>): _tanstack_react_query0.UseMutationResult<void, Error, `0x${string}`[], unknown>;
849
+ //#endregion
850
+ //#region src/token/use-revoke-session.d.ts
820
851
  /**
821
852
  * Revoke the session signature for the connected wallet without
822
853
  * specifying contract addresses. Useful for wallet disconnect handlers.
@@ -827,23 +858,25 @@ declare function useRevoke(options?: UseMutationOptions<void, Error, Address[]>)
827
858
  * revokeSession();
828
859
  * ```
829
860
  */
830
- declare function useRevokeSession(options?: UseMutationOptions<void, Error, void>): _tanstack_react_query.UseMutationResult<void, Error, void, unknown>;
831
-
861
+ declare function useRevokeSession(options?: UseMutationOptions<void, Error, void>): _tanstack_react_query0.UseMutationResult<void, Error, void, unknown>;
862
+ //#endregion
863
+ //#region src/token/optimistic-balance-update.d.ts
832
864
  type OptimisticBalanceSnapshot = Array<[QueryKey, bigint | undefined]>;
833
865
  /** Combined context returned by optimistic `onMutate`. */
834
866
  interface OptimisticMutateContext {
835
- snapshot: OptimisticBalanceSnapshot;
836
- callerContext?: unknown;
867
+ snapshot: OptimisticBalanceSnapshot;
868
+ callerContext?: unknown;
837
869
  }
838
-
870
+ //#endregion
871
+ //#region src/token/use-confidential-transfer.d.ts
839
872
  /** Configuration for {@link useConfidentialTransfer}. */
840
873
  interface UseConfidentialTransferConfig extends UseZamaConfig {
841
- /**
842
- * When `true`, optimistically subtracts the transfer amount from cached balance
843
- * before the transaction confirms. Rolls back on error.
844
- * @defaultValue false
845
- */
846
- optimistic?: boolean;
874
+ /**
875
+ * When `true`, optimistically subtracts the transfer amount from cached balance
876
+ * before the transaction confirms. Rolls back on error.
877
+ * @defaultValue false
878
+ */
879
+ optimistic?: boolean;
847
880
  }
848
881
  /**
849
882
  * Encrypt and send a confidential transfer. Invalidates balance caches on success.
@@ -875,8 +908,9 @@ interface UseConfidentialTransferConfig extends UseZamaConfig {
875
908
  * );
876
909
  * ```
877
910
  */
878
- declare function useConfidentialTransfer(config: UseConfidentialTransferConfig, options?: UseMutationOptions<TransactionResult, Error, ConfidentialTransferParams, OptimisticMutateContext>): _tanstack_react_query.UseMutationResult<TransactionResult, Error, ConfidentialTransferParams, OptimisticMutateContext>;
879
-
911
+ declare function useConfidentialTransfer(config: UseConfidentialTransferConfig, options?: UseMutationOptions<TransactionResult$1, Error, ConfidentialTransferParams$1, OptimisticMutateContext>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, ConfidentialTransferParams$1, OptimisticMutateContext>;
912
+ //#endregion
913
+ //#region src/token/use-confidential-transfer-from.d.ts
880
914
  /**
881
915
  * Operator transfer on behalf of another address. Caller must be an approved operator.
882
916
  * Invalidates balance caches on success.
@@ -890,8 +924,9 @@ declare function useConfidentialTransfer(config: UseConfidentialTransferConfig,
890
924
  * transferFrom.mutate({ from: "0xOwner", to: "0xRecipient", amount: 500n });
891
925
  * ```
892
926
  */
893
- declare function useConfidentialTransferFrom(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult, Error, ConfidentialTransferFromParams, Address>): _tanstack_react_query.UseMutationResult<TransactionResult, Error, ConfidentialTransferFromParams, `0x${string}`>;
894
-
927
+ declare function useConfidentialTransferFrom(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, ConfidentialTransferFromParams$1, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, ConfidentialTransferFromParams$1, `0x${string}`>;
928
+ //#endregion
929
+ //#region src/token/use-confidential-approve.d.ts
895
930
  /**
896
931
  * Set operator approval for a confidential token. Defaults to 1 hour.
897
932
  *
@@ -908,21 +943,22 @@ declare function useConfidentialTransferFrom(config: UseZamaConfig, options?: Us
908
943
  * approve.mutate({ spender: "0xOperator" });
909
944
  * ```
910
945
  */
911
- declare function useConfidentialApprove(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult, Error, ConfidentialApproveParams, Address>): _tanstack_react_query.UseMutationResult<TransactionResult, Error, ConfidentialApproveParams, `0x${string}`>;
912
-
946
+ declare function useConfidentialApprove(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, ConfidentialApproveParams$1, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, ConfidentialApproveParams$1, `0x${string}`>;
947
+ //#endregion
948
+ //#region src/token/use-confidential-is-approved.d.ts
913
949
  /** Configuration for {@link useConfidentialIsApproved}. */
914
950
  interface UseConfidentialIsApprovedConfig extends UseZamaConfig {
915
- /** Address to check approval for. Pass `undefined` to disable the query. */
916
- spender: Address | undefined;
917
- /** Token holder address. Defaults to the connected wallet. */
918
- holder?: Address;
951
+ /** Address to check approval for. Pass `undefined` to disable the query. */
952
+ spender: Address$1 | undefined;
953
+ /** Token holder address. Defaults to the connected wallet. */
954
+ holder?: Address$1;
919
955
  }
920
956
  /** Configuration for {@link useConfidentialIsApprovedSuspense}. */
921
957
  interface UseConfidentialIsApprovedSuspenseConfig extends UseZamaConfig {
922
- /** Address to check approval for. */
923
- spender: Address;
924
- /** Token holder address. Defaults to the connected wallet. */
925
- holder?: Address;
958
+ /** Address to check approval for. */
959
+ spender: Address$1;
960
+ /** Token holder address. Defaults to the connected wallet. */
961
+ holder?: Address$1;
926
962
  }
927
963
  /**
928
964
  * Check if a spender is an approved operator for a given holder (defaults to connected wallet).
@@ -940,7 +976,7 @@ interface UseConfidentialIsApprovedSuspenseConfig extends UseZamaConfig {
940
976
  * });
941
977
  * ```
942
978
  */
943
- declare function useConfidentialIsApproved(config: UseConfidentialIsApprovedConfig, options?: Omit<UseQueryOptions<boolean, Error>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<unknown, Error>;
979
+ declare function useConfidentialIsApproved(config: UseConfidentialIsApprovedConfig, options?: Omit<UseQueryOptions<boolean, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<unknown, Error>;
944
980
  /**
945
981
  * Suspense variant of {@link useConfidentialIsApproved}.
946
982
  * Suspends rendering until the approval check resolves.
@@ -957,16 +993,17 @@ declare function useConfidentialIsApproved(config: UseConfidentialIsApprovedConf
957
993
  * });
958
994
  * ```
959
995
  */
960
- declare function useConfidentialIsApprovedSuspense(config: UseConfidentialIsApprovedSuspenseConfig): _tanstack_react_query.UseSuspenseQueryResult<boolean, Error>;
961
-
996
+ declare function useConfidentialIsApprovedSuspense(config: UseConfidentialIsApprovedSuspenseConfig): _tanstack_react_query0.UseSuspenseQueryResult<boolean, Error>;
997
+ //#endregion
998
+ //#region src/token/use-shield.d.ts
962
999
  /** Configuration for {@link useShield}. */
963
1000
  interface UseShieldConfig extends UseZamaConfig {
964
- /**
965
- * When `true`, optimistically adds the wrap amount to the cached confidential balance
966
- * before the transaction confirms. Rolls back on error.
967
- * @defaultValue false
968
- */
969
- optimistic?: boolean;
1001
+ /**
1002
+ * When `true`, optimistically adds the wrap amount to the cached confidential balance
1003
+ * before the transaction confirms. Rolls back on error.
1004
+ * @defaultValue false
1005
+ */
1006
+ optimistic?: boolean;
970
1007
  }
971
1008
  /**
972
1009
  * Shield public ERC-20 tokens into confidential tokens.
@@ -987,8 +1024,9 @@ interface UseShieldConfig extends UseZamaConfig {
987
1024
  * shield.mutate({ amount: 1000n });
988
1025
  * ```
989
1026
  */
990
- declare function useShield(config: UseShieldConfig, options?: UseMutationOptions<TransactionResult, Error, ShieldParams, OptimisticMutateContext>): _tanstack_react_query.UseMutationResult<TransactionResult, Error, ShieldParams, OptimisticMutateContext>;
991
-
1027
+ declare function useShield(config: UseShieldConfig, options?: UseMutationOptions<TransactionResult$1, Error, ShieldParams$1, OptimisticMutateContext>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, ShieldParams$1, OptimisticMutateContext>;
1028
+ //#endregion
1029
+ //#region src/token/use-shield-eth.d.ts
992
1030
  /**
993
1031
  * Shield native ETH into confidential tokens.
994
1032
  * Invalidates balance caches on success.
@@ -1002,8 +1040,9 @@ declare function useShield(config: UseShieldConfig, options?: UseMutationOptions
1002
1040
  * shieldETH.mutate({ amount: 1000000000000000000n }); // 1 ETH
1003
1041
  * ```
1004
1042
  */
1005
- declare function useShieldETH(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult, Error, ShieldETHParams, Address>): _tanstack_react_query.UseMutationResult<TransactionResult, Error, ShieldETHParams, `0x${string}`>;
1006
-
1043
+ declare function useShieldETH(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, ShieldETHParams$1, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, ShieldETHParams$1, `0x${string}`>;
1044
+ //#endregion
1045
+ //#region src/token/use-unwrap.d.ts
1007
1046
  /**
1008
1047
  * Request an unwrap for a specific amount. Encrypts the amount first.
1009
1048
  * Call {@link useFinalizeUnwrap} after the request is processed on-chain,
@@ -1018,8 +1057,9 @@ declare function useShieldETH(config: UseZamaConfig, options?: UseMutationOption
1018
1057
  * unwrap.mutate({ amount: 500n });
1019
1058
  * ```
1020
1059
  */
1021
- declare function useUnwrap(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult, Error, UnwrapParams, Address>): _tanstack_react_query.UseMutationResult<TransactionResult, Error, UnwrapParams, `0x${string}`>;
1022
-
1060
+ declare function useUnwrap(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, UnwrapParams$1, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, UnwrapParams$1, `0x${string}`>;
1061
+ //#endregion
1062
+ //#region src/token/use-unwrap-all.d.ts
1023
1063
  /**
1024
1064
  * Request an unwrap for the entire confidential balance.
1025
1065
  * Uses the on-chain balance handle directly (no encryption needed).
@@ -1034,8 +1074,9 @@ declare function useUnwrap(config: UseZamaConfig, options?: UseMutationOptions<T
1034
1074
  * unwrapAll.mutate();
1035
1075
  * ```
1036
1076
  */
1037
- declare function useUnwrapAll(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult, Error, void, Address>): _tanstack_react_query.UseMutationResult<TransactionResult, Error, void, `0x${string}`>;
1038
-
1077
+ declare function useUnwrapAll(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, void, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, void, `0x${string}`>;
1078
+ //#endregion
1079
+ //#region src/token/use-finalize-unwrap.d.ts
1039
1080
  /**
1040
1081
  * Complete an unwrap by providing the public decryption proof.
1041
1082
  * Call this after an unwrap request has been processed on-chain.
@@ -1049,8 +1090,9 @@ declare function useUnwrapAll(config: UseZamaConfig, options?: UseMutationOption
1049
1090
  * finalize.mutate({ burnAmountHandle: event.encryptedAmount });
1050
1091
  * ```
1051
1092
  */
1052
- declare function useFinalizeUnwrap(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult, Error, FinalizeUnwrapParams, Address>): _tanstack_react_query.UseMutationResult<TransactionResult, Error, FinalizeUnwrapParams, `0x${string}`>;
1053
-
1093
+ declare function useFinalizeUnwrap(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, FinalizeUnwrapParams$1, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, FinalizeUnwrapParams$1, `0x${string}`>;
1094
+ //#endregion
1095
+ //#region src/token/use-unshield.d.ts
1054
1096
  /**
1055
1097
  * Unshield a specific amount and finalize in one call.
1056
1098
  * Orchestrates: unwrap → wait for receipt → parse event → finalize.
@@ -1070,8 +1112,9 @@ declare function useFinalizeUnwrap(config: UseZamaConfig, options?: UseMutationO
1070
1112
  * unshield.mutate({ amount: 500n });
1071
1113
  * ```
1072
1114
  */
1073
- declare function useUnshield(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult, Error, UnshieldParams, Address>): _tanstack_react_query.UseMutationResult<TransactionResult, Error, UnshieldParams, `0x${string}`>;
1074
-
1115
+ declare function useUnshield(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, UnshieldParams$1, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, UnshieldParams$1, `0x${string}`>;
1116
+ //#endregion
1117
+ //#region src/token/use-unshield-all.d.ts
1075
1118
  /**
1076
1119
  * Unshield the entire balance and finalize in one call.
1077
1120
  * Orchestrates: unwrapAll → wait for receipt → parse event → finalize.
@@ -1085,8 +1128,9 @@ declare function useUnshield(config: UseZamaConfig, options?: UseMutationOptions
1085
1128
  * unshieldAll.mutate();
1086
1129
  * ```
1087
1130
  */
1088
- declare function useUnshieldAll(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult, Error, UnshieldAllParams | void, Address>): _tanstack_react_query.UseMutationResult<TransactionResult, Error, void | UnshieldAllParams, `0x${string}`>;
1089
-
1131
+ declare function useUnshieldAll(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, UnshieldAllParams$1 | void, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, void | UnshieldAllParams$1, `0x${string}`>;
1132
+ //#endregion
1133
+ //#region src/token/use-resume-unshield.d.ts
1090
1134
  /**
1091
1135
  * Resume an interrupted unshield from an existing unwrap tx hash.
1092
1136
  * Useful when the user submitted the unwrap but the finalize step was
@@ -1105,14 +1149,15 @@ declare function useUnshieldAll(config: UseZamaConfig, options?: UseMutationOpti
1105
1149
  * resumeUnshield.mutate({ unwrapTxHash: "0xabc..." });
1106
1150
  * ```
1107
1151
  */
1108
- declare function useResumeUnshield(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult, Error, ResumeUnshieldParams, Address>): _tanstack_react_query.UseMutationResult<TransactionResult, Error, ResumeUnshieldParams, `0x${string}`>;
1109
-
1152
+ declare function useResumeUnshield(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, ResumeUnshieldParams$1, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, ResumeUnshieldParams$1, `0x${string}`>;
1153
+ //#endregion
1154
+ //#region src/token/use-underlying-allowance.d.ts
1110
1155
  /** Configuration for {@link useUnderlyingAllowance}. */
1111
1156
  interface UseUnderlyingAllowanceConfig {
1112
- /** Address of the confidential token contract used to scope the query cache. */
1113
- tokenAddress: Address;
1114
- /** Address of the wrapper contract whose underlying ERC-20 allowance is checked. */
1115
- wrapperAddress: Address;
1157
+ /** Address of the confidential token contract used to scope the query cache. */
1158
+ tokenAddress: Address$1;
1159
+ /** Address of the wrapper contract whose underlying ERC-20 allowance is checked. */
1160
+ wrapperAddress: Address$1;
1116
1161
  }
1117
1162
  /**
1118
1163
  * Read the underlying ERC-20 allowance granted to the wrapper contract.
@@ -1130,7 +1175,7 @@ interface UseUnderlyingAllowanceConfig {
1130
1175
  * });
1131
1176
  * ```
1132
1177
  */
1133
- declare function useUnderlyingAllowance(config: UseUnderlyingAllowanceConfig, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<bigint, Error>;
1178
+ declare function useUnderlyingAllowance(config: UseUnderlyingAllowanceConfig, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<bigint, Error>;
1134
1179
  /**
1135
1180
  * Suspense variant of {@link useUnderlyingAllowance}.
1136
1181
  * Suspends rendering until the allowance is loaded.
@@ -1146,21 +1191,22 @@ declare function useUnderlyingAllowance(config: UseUnderlyingAllowanceConfig, op
1146
1191
  * });
1147
1192
  * ```
1148
1193
  */
1149
- declare function useUnderlyingAllowanceSuspense(config: UseUnderlyingAllowanceConfig): _tanstack_react_query.UseSuspenseQueryResult<bigint, Error>;
1150
-
1194
+ declare function useUnderlyingAllowanceSuspense(config: UseUnderlyingAllowanceConfig): _tanstack_react_query0.UseSuspenseQueryResult<bigint, Error>;
1195
+ //#endregion
1196
+ //#region src/token/use-wrapper-discovery.d.ts
1151
1197
  /** Configuration for {@link useWrapperDiscovery}. */
1152
1198
  interface UseWrapperDiscoveryConfig {
1153
- /** Address of the underlying ERC-20 token. */
1154
- tokenAddress: Address;
1155
- /** Address of the wrapper coordinator. Pass `undefined` to disable the query. */
1156
- coordinatorAddress: Address | undefined;
1199
+ /** Address of the underlying ERC-20 token. */
1200
+ tokenAddress: Address$1;
1201
+ /** Address of the wrapper coordinator. Pass `undefined` to disable the query. */
1202
+ coordinatorAddress: Address$1 | undefined;
1157
1203
  }
1158
1204
  /** Configuration for {@link useWrapperDiscoverySuspense}. */
1159
1205
  interface UseWrapperDiscoverySuspenseConfig {
1160
- /** Address of the underlying ERC-20 token. */
1161
- tokenAddress: Address;
1162
- /** Address of the wrapper coordinator. */
1163
- coordinatorAddress: Address;
1206
+ /** Address of the underlying ERC-20 token. */
1207
+ tokenAddress: Address$1;
1208
+ /** Address of the wrapper coordinator. */
1209
+ coordinatorAddress: Address$1;
1164
1210
  }
1165
1211
  /**
1166
1212
  * Discover the wrapper contract for an ERC-20 token.
@@ -1179,7 +1225,7 @@ interface UseWrapperDiscoverySuspenseConfig {
1179
1225
  * });
1180
1226
  * ```
1181
1227
  */
1182
- declare function useWrapperDiscovery(config: UseWrapperDiscoveryConfig, options?: Omit<UseQueryOptions<Address | null, Error>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<`0x${string}` | null, Error>;
1228
+ declare function useWrapperDiscovery(config: UseWrapperDiscoveryConfig, options?: Omit<UseQueryOptions<Address$1 | null, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<`0x${string}` | null, Error>;
1183
1229
  /**
1184
1230
  * Suspense variant of {@link useWrapperDiscovery}.
1185
1231
  * Suspends rendering until the wrapper address is resolved.
@@ -1195,8 +1241,9 @@ declare function useWrapperDiscovery(config: UseWrapperDiscoveryConfig, options?
1195
1241
  * });
1196
1242
  * ```
1197
1243
  */
1198
- declare function useWrapperDiscoverySuspense(config: UseWrapperDiscoverySuspenseConfig): _tanstack_react_query.UseSuspenseQueryResult<`0x${string}` | null, Error>;
1199
-
1244
+ declare function useWrapperDiscoverySuspense(config: UseWrapperDiscoverySuspenseConfig): _tanstack_react_query0.UseSuspenseQueryResult<`0x${string}` | null, Error>;
1245
+ //#endregion
1246
+ //#region src/token/use-metadata.d.ts
1200
1247
  /**
1201
1248
  * Read ERC-20 token metadata (name, symbol, decimals).
1202
1249
  * Fetches all three in parallel. Cached indefinitely since metadata is immutable.
@@ -1211,7 +1258,7 @@ declare function useWrapperDiscoverySuspense(config: UseWrapperDiscoverySuspense
1211
1258
  * // metadata?.name, metadata?.symbol, metadata?.decimals
1212
1259
  * ```
1213
1260
  */
1214
- declare function useMetadata(tokenAddress: Address, options?: Omit<UseQueryOptions<TokenMetadata, Error>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<TokenMetadata, Error>;
1261
+ declare function useMetadata(tokenAddress: Address$1, options?: Omit<UseQueryOptions<TokenMetadata, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<TokenMetadata, Error>;
1215
1262
  /**
1216
1263
  * Suspense variant of {@link useMetadata}.
1217
1264
  * Suspends rendering until metadata is loaded.
@@ -1224,18 +1271,19 @@ declare function useMetadata(tokenAddress: Address, options?: Omit<UseQueryOptio
1224
1271
  * const { data: metadata } = useMetadataSuspense("0xToken");
1225
1272
  * ```
1226
1273
  */
1227
- declare function useMetadataSuspense(tokenAddress: Address): _tanstack_react_query.UseSuspenseQueryResult<TokenMetadata, Error>;
1228
-
1274
+ declare function useMetadataSuspense(tokenAddress: Address$1): _tanstack_react_query0.UseSuspenseQueryResult<TokenMetadata, Error>;
1275
+ //#endregion
1276
+ //#region src/token/use-activity-feed.d.ts
1229
1277
  /** Configuration for {@link useActivityFeed}. */
1230
1278
  interface UseActivityFeedConfig {
1231
- /** Address of the confidential token contract. */
1232
- tokenAddress: Address;
1233
- /** Connected wallet address. Pass `undefined` to disable the query. */
1234
- userAddress: Address | undefined;
1235
- /** Raw event logs from the provider (viem, ethers, etc.). Pass `undefined` to disable. */
1236
- logs: readonly (RawLog & Partial<ActivityLogMetadata>)[] | undefined;
1237
- /** Whether to batch-decrypt encrypted transfer amounts. Default: `true`. */
1238
- decrypt?: boolean;
1279
+ /** Address of the confidential token contract. */
1280
+ tokenAddress: Address$1;
1281
+ /** Connected wallet address. Pass `undefined` to disable the query. */
1282
+ userAddress: Address$1 | undefined;
1283
+ /** Raw event logs from the provider (viem, ethers, etc.). Pass `undefined` to disable. */
1284
+ logs: readonly (RawLog$1 & Partial<ActivityLogMetadata$1>)[] | undefined;
1285
+ /** Whether to batch-decrypt encrypted transfer amounts. Default: `true`. */
1286
+ decrypt?: boolean;
1239
1287
  }
1240
1288
  /**
1241
1289
  * Two-phase activity feed hook.
@@ -1257,8 +1305,9 @@ interface UseActivityFeedConfig {
1257
1305
  * });
1258
1306
  * ```
1259
1307
  */
1260
- declare function useActivityFeed(config: UseActivityFeedConfig): _tanstack_react_query.UseQueryResult<ActivityItem[], Error>;
1261
-
1308
+ declare function useActivityFeed(config: UseActivityFeedConfig): _tanstack_react_query0.UseQueryResult<ActivityItem$1[], Error>;
1309
+ //#endregion
1310
+ //#region src/token/use-approve-underlying.d.ts
1262
1311
  /**
1263
1312
  * Approve the wrapper contract to spend the underlying ERC-20.
1264
1313
  * Defaults to max uint256. Resets to zero first if there's an existing
@@ -1274,8 +1323,9 @@ declare function useActivityFeed(config: UseActivityFeedConfig): _tanstack_react
1274
1323
  * approve.mutate({ amount: 1000n }); // exact amount
1275
1324
  * ```
1276
1325
  */
1277
- declare function useApproveUnderlying(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult, Error, ApproveUnderlyingParams, Address>): _tanstack_react_query.UseMutationResult<TransactionResult, Error, ApproveUnderlyingParams, `0x${string}`>;
1278
-
1326
+ declare function useApproveUnderlying(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, ApproveUnderlyingParams$1, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, ApproveUnderlyingParams$1, `0x${string}`>;
1327
+ //#endregion
1328
+ //#region src/token/use-is-confidential.d.ts
1279
1329
  /**
1280
1330
  * Check if a token supports the ERC-7984 confidential interface via ERC-165.
1281
1331
  * Result is cached indefinitely since interface support does not change.
@@ -1289,7 +1339,7 @@ declare function useApproveUnderlying(config: UseZamaConfig, options?: UseMutati
1289
1339
  * const { data: isConfidential } = useIsConfidential("0xToken");
1290
1340
  * ```
1291
1341
  */
1292
- declare function useIsConfidential(tokenAddress: Address, options?: Omit<UseQueryOptions<boolean, Error>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<boolean, Error>;
1342
+ declare function useIsConfidential(tokenAddress: Address$1, options?: Omit<UseQueryOptions<boolean, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<boolean, Error>;
1293
1343
  /**
1294
1344
  * Suspense variant of {@link useIsConfidential}.
1295
1345
  * Suspends rendering until the ERC-165 check resolves.
@@ -1302,7 +1352,7 @@ declare function useIsConfidential(tokenAddress: Address, options?: Omit<UseQuer
1302
1352
  * const { data: isConfidential } = useIsConfidentialSuspense("0xToken");
1303
1353
  * ```
1304
1354
  */
1305
- declare function useIsConfidentialSuspense(tokenAddress: Address): _tanstack_react_query.UseSuspenseQueryResult<boolean, Error>;
1355
+ declare function useIsConfidentialSuspense(tokenAddress: Address$1): _tanstack_react_query0.UseSuspenseQueryResult<boolean, Error>;
1306
1356
  /**
1307
1357
  * Check if a token supports the ERC-7984 wrapper interface via ERC-165.
1308
1358
  * Result is cached indefinitely since interface support does not change.
@@ -1316,7 +1366,7 @@ declare function useIsConfidentialSuspense(tokenAddress: Address): _tanstack_rea
1316
1366
  * const { data: isWrapper } = useIsWrapper("0xToken");
1317
1367
  * ```
1318
1368
  */
1319
- declare function useIsWrapper(tokenAddress: Address, options?: Omit<UseQueryOptions<boolean, Error>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<boolean, Error>;
1369
+ declare function useIsWrapper(tokenAddress: Address$1, options?: Omit<UseQueryOptions<boolean, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<boolean, Error>;
1320
1370
  /**
1321
1371
  * Suspense variant of {@link useIsWrapper}.
1322
1372
  * Suspends rendering until the ERC-165 check resolves.
@@ -1329,8 +1379,9 @@ declare function useIsWrapper(tokenAddress: Address, options?: Omit<UseQueryOpti
1329
1379
  * const { data: isWrapper } = useIsWrapperSuspense("0xToken");
1330
1380
  * ```
1331
1381
  */
1332
- declare function useIsWrapperSuspense(tokenAddress: Address): _tanstack_react_query.UseSuspenseQueryResult<boolean, Error>;
1333
-
1382
+ declare function useIsWrapperSuspense(tokenAddress: Address$1): _tanstack_react_query0.UseSuspenseQueryResult<boolean, Error>;
1383
+ //#endregion
1384
+ //#region src/token/use-total-supply.d.ts
1334
1385
  /**
1335
1386
  * Read the total supply of a token.
1336
1387
  * Stale after 30 seconds to balance freshness and RPC cost.
@@ -1344,7 +1395,7 @@ declare function useIsWrapperSuspense(tokenAddress: Address): _tanstack_react_qu
1344
1395
  * const { data: totalSupply } = useTotalSupply("0xToken");
1345
1396
  * ```
1346
1397
  */
1347
- declare function useTotalSupply(tokenAddress: Address, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<bigint, Error>;
1398
+ declare function useTotalSupply(tokenAddress: Address$1, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<bigint, Error>;
1348
1399
  /**
1349
1400
  * Suspense variant of {@link useTotalSupply}.
1350
1401
  * Suspends rendering until the total supply is loaded.
@@ -1357,18 +1408,19 @@ declare function useTotalSupply(tokenAddress: Address, options?: Omit<UseQueryOp
1357
1408
  * const { data: totalSupply } = useTotalSupplySuspense("0xToken");
1358
1409
  * ```
1359
1410
  */
1360
- declare function useTotalSupplySuspense(tokenAddress: Address): _tanstack_react_query.UseSuspenseQueryResult<bigint, Error>;
1361
-
1411
+ declare function useTotalSupplySuspense(tokenAddress: Address$1): _tanstack_react_query0.UseSuspenseQueryResult<bigint, Error>;
1412
+ //#endregion
1413
+ //#region src/token/use-fees.d.ts
1362
1414
  /** Configuration for {@link useShieldFee} and {@link useUnshieldFee}. */
1363
1415
  interface UseFeeConfig {
1364
- /** Address of the fee manager contract. */
1365
- feeManagerAddress: Address;
1366
- /** Amount to calculate the fee for. */
1367
- amount: bigint;
1368
- /** Sender address. */
1369
- from: Address;
1370
- /** Receiver address. */
1371
- to: Address;
1416
+ /** Address of the fee manager contract. */
1417
+ feeManagerAddress: Address$1;
1418
+ /** Amount to calculate the fee for. */
1419
+ amount: bigint;
1420
+ /** Sender address. */
1421
+ from: Address$1;
1422
+ /** Receiver address. */
1423
+ to: Address$1;
1372
1424
  }
1373
1425
  /**
1374
1426
  * Read the shield fee for a given amount and address pair.
@@ -1387,7 +1439,7 @@ interface UseFeeConfig {
1387
1439
  * });
1388
1440
  * ```
1389
1441
  */
1390
- declare function useShieldFee(config: UseFeeConfig, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<bigint, Error>;
1442
+ declare function useShieldFee(config: UseFeeConfig, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<bigint, Error>;
1391
1443
  /**
1392
1444
  * Read the unshield fee for a given amount and address pair.
1393
1445
  *
@@ -1405,7 +1457,7 @@ declare function useShieldFee(config: UseFeeConfig, options?: Omit<UseQueryOptio
1405
1457
  * });
1406
1458
  * ```
1407
1459
  */
1408
- declare function useUnshieldFee(config: UseFeeConfig, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<bigint, Error>;
1460
+ declare function useUnshieldFee(config: UseFeeConfig, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<bigint, Error>;
1409
1461
  /**
1410
1462
  * Read the batch transfer fee from the fee manager.
1411
1463
  *
@@ -1418,7 +1470,7 @@ declare function useUnshieldFee(config: UseFeeConfig, options?: Omit<UseQueryOpt
1418
1470
  * const { data: fee } = useBatchTransferFee("0xFeeManager");
1419
1471
  * ```
1420
1472
  */
1421
- declare function useBatchTransferFee(feeManagerAddress: Address, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<bigint, Error>;
1473
+ declare function useBatchTransferFee(feeManagerAddress: Address$1, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<bigint, Error>;
1422
1474
  /**
1423
1475
  * Read the fee recipient address from the fee manager.
1424
1476
  *
@@ -1431,6 +1483,7 @@ declare function useBatchTransferFee(feeManagerAddress: Address, options?: Omit<
1431
1483
  * const { data: recipient } = useFeeRecipient("0xFeeManager");
1432
1484
  * ```
1433
1485
  */
1434
- declare function useFeeRecipient(feeManagerAddress: Address, options?: Omit<UseQueryOptions<Address, Error>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<`0x${string}`, Error>;
1435
-
1436
- export { type CreateDelegatedUserDecryptEIP712Params, type CreateEIP712Params, type DecryptHandle, type OptimisticBalanceSnapshot, type OptimisticMutateContext, type PublicKeyData, type PublicParamsData, type UseActivityFeedConfig, type UseConfidentialBalanceConfig, type UseConfidentialBalanceOptions, type UseConfidentialBalancesConfig, type UseConfidentialBalancesOptions, type UseConfidentialIsApprovedConfig, type UseConfidentialIsApprovedSuspenseConfig, type UseConfidentialTransferConfig, type UseFeeConfig, type UseShieldConfig, type UseUnderlyingAllowanceConfig, type UseUserDecryptFlowConfig, type UseWrapperDiscoveryConfig, type UseWrapperDiscoverySuspenseConfig, type UseZamaConfig, type UserDecryptFlowCallbacks, type UserDecryptFlowParams, ZamaProvider, type ZamaProviderProps, decryptionKeys, useActivityFeed, useAllow, useApproveUnderlying, useBatchTransferFee, useConfidentialApprove, useConfidentialBalance, useConfidentialBalances, useConfidentialIsApproved, useConfidentialIsApprovedSuspense, useConfidentialTransfer, useConfidentialTransferFrom, useCreateDelegatedUserDecryptEIP712, useCreateEIP712, useDelegatedUserDecrypt, useEncrypt, useFeeRecipient, useFinalizeUnwrap, useGenerateKeypair, useIsAllowed, useIsConfidential, useIsConfidentialSuspense, useIsWrapper, useIsWrapperSuspense, useMetadata, useMetadataSuspense, usePublicDecrypt, usePublicKey, usePublicParams, useReadonlyToken, useRequestZKProofVerification, useResumeUnshield, useRevoke, useRevokeSession, useShield, useShieldETH, useShieldFee, useToken, useTotalSupply, useTotalSupplySuspense, useUnderlyingAllowance, useUnderlyingAllowanceSuspense, useUnshield, useUnshieldAll, useUnshieldFee, useUnwrap, useUnwrapAll, useUserDecrypt, useUserDecryptFlow, useUserDecryptedValue, useUserDecryptedValues, useWrapperDiscovery, useWrapperDiscoverySuspense, useZamaSDK };
1486
+ declare function useFeeRecipient(feeManagerAddress: Address$1, options?: Omit<UseQueryOptions<Address$1, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<`0x${string}`, Error>;
1487
+ //#endregion
1488
+ export { type ActivityAmount, type ActivityDirection, type ActivityItem, type ActivityLogMetadata, type ActivityType, type Address, ApprovalFailedError, type ApproveSubmittedEvent, type ApproveUnderlyingParams, type ApproveUnderlyingSubmittedEvent, BATCH_SWAP_ABI, type BaseEvent, type BatchDecryptOptions, type BatchTransferData, ChromeSessionStorage, type ClearValueType, type ConfidentialApproveParams, type ConfidentialBalancesData, type ConfidentialTransferEvent, type ConfidentialTransferFromParams, type ConfidentialTransferParams, type ContractAbi, type CreateDelegatedUserDecryptEIP712Params, type CreateEIP712Params, type CredentialsAllowedEvent, type CredentialsCachedEvent, type CredentialsCreatedEvent, type CredentialsCreatingEvent, type CredentialsExpiredEvent, type CredentialsLoadingEvent, CredentialsManager, type CredentialsManagerConfig, type CredentialsRevokedEvent, DEPLOYMENT_COORDINATOR_ABI, type DecryptEndEvent, type DecryptErrorEvent, type DecryptHandle, type DecryptStartEvent, DecryptionFailedError, type DelegatedUserDecryptParams, type EIP712TypedData, ENCRYPTION_ABI, ERC165_ABI, ERC20_ABI, ERC20_METADATA_ABI, ERC7984_INTERFACE_ID, ERC7984_WRAPPER_INTERFACE_ID, type EncryptEndEvent, type EncryptErrorEvent, type EncryptInput, type EncryptParams, type EncryptResult, type EncryptStartEvent, EncryptionFailedError, FEE_MANAGER_ABI, 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, MainnetConfig, MemoryStorage, type NetworkType, NoCiphertextError, type OnChainEvent, type OptimisticBalanceSnapshot, type OptimisticMutateContext, 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, SepoliaConfig, type SessionExpiredEvent, type ShieldCallbacks, type ShieldETHParams, type ShieldParams, type ShieldSubmittedEvent, SigningFailedError, SigningRejectedError, type StoredCredentials, TOKEN_TOPICS, TRANSFER_BATCHER_ABI, Token, type TokenConfig, type TokenMetadata, 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 UseFeeConfig, type UseShieldConfig, type UseUnderlyingAllowanceConfig, type UseUserDecryptFlowConfig, type UseWrapperDiscoveryConfig, type UseWrapperDiscoverySuspenseConfig, type UseZamaConfig, type UserDecryptFlowCallbacks, type UserDecryptFlowParams, type UserDecryptParams, WRAPPER_ABI, type WrappedEvent, 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, batchTransferFeeQueryOptions, chromeSessionStorage, clearPendingUnshield, confidentialApproveMutationOptions, confidentialBalanceOfContract, confidentialBalanceQueryOptions, confidentialBalancesQueryOptions, confidentialBatchTransferContract, confidentialHandleQueryOptions, confidentialHandlesQueryOptions, confidentialIsApprovedQueryOptions, confidentialTotalSupplyContract, confidentialTransferContract, confidentialTransferFromContract, confidentialTransferFromMutationOptions, confidentialTransferMutationOptions, decimalsContract, decodeConfidentialTransfer, decodeOnChainEvent, decodeOnChainEvents, decodeUnwrapRequested, decodeUnwrappedFinalized, decodeUnwrappedStarted, decodeWrapped, decryptionKeys, deploymentCoordinatorContract, encryptMutationOptions, extractEncryptedHandles, feeRecipientQueryOptions, filterQueryOptions, finalizeUnwrapContract, finalizeUnwrapMutationOptions, findUnwrapRequested, findWrapped, getBatchTransferFeeContract, getFeeRecipientContract, getUnwrapFeeContract, getWrapFeeContract, getWrapperContract, hashFn, indexedDBStorage, isAllowedQueryOptions, isConfidentialQueryOptions, isConfidentialTokenContract, isConfidentialWrapperContract, isFinalizeUnwrapOperatorContract, isOperatorContract, isWrapperQueryOptions, loadPendingUnshield, matchZamaError, nameContract, parseActivityFeed, publicKeyQueryOptions, publicParamsQueryOptions, rateContract, resumeUnshieldMutationOptions, 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, useBatchTransferFee, useConfidentialApprove, useConfidentialBalance, useConfidentialBalances, useConfidentialIsApproved, useConfidentialIsApprovedSuspense, useConfidentialTransfer, useConfidentialTransferFrom, useCreateDelegatedUserDecryptEIP712, useCreateEIP712, useDelegatedUserDecrypt, useEncrypt, useFeeRecipient, useFinalizeUnwrap, useGenerateKeypair, useIsAllowed, useIsConfidential, useIsConfidentialSuspense, useIsWrapper, useIsWrapperSuspense, useMetadata, useMetadataSuspense, usePublicDecrypt, usePublicKey, usePublicParams, useReadonlyToken, useRequestZKProofVerification, useResumeUnshield, useRevoke, useRevokeSession, useShield, useShieldETH, useShieldFee, useToken, useTotalSupply, useTotalSupplySuspense, useUnderlyingAllowance, useUnderlyingAllowanceSuspense, useUnshield, useUnshieldAll, useUnshieldFee, useUnwrap, useUnwrapAll, useUserDecrypt, useUserDecryptFlow, useUserDecryptedValue, useUserDecryptedValues, useWrapperDiscovery, useWrapperDiscoverySuspense, useZamaSDK, wrapContract, wrapETHContract, wrapperDiscoveryQueryOptions, wrapperExistsContract, zamaQueryKeys };
1489
+ //# sourceMappingURL=index.d.ts.map