@zama-fhe/sdk 3.3.0 → 3.3.1-alpha.2

package/dist/esm/{index-C1Mtc8Rw.d.ts → zama-sdk-q4_qt64Q.d.ts}

@@ -1,9 +1,7 @@
-import { n as FheChain } from "./types-BgczXqW2.js";
-import { E as ShieldOptions, F as GenericSigner, H as TransactionResult, I as WalletAccount, M as UnshieldCallbacks, N as GenericStorage, O as TransferOptions, P as GenericProvider, R as WalletAccountListener, Y as WriteContractConfig, a as StoredTransportKeyPairWithPermits, d as EncryptParams, f as EncryptResult, g as PublicDecryptResult, j as TransferCallbacks, k as UnshieldOptions, p as EncryptedValue, pt as GenericLogger, s as ClearValue } from "./relayer-cleartext-CSeMlmGO.js";
-import { E as TransactionOperation, P as ZamaSDKEventInput, a as ZamaConfig, n as RelayerConfig, s as ZamaConfigGeneric, u as RelayerDispatcher } from "./types-Gn5MeDsr.js";
+import { u as FheChain } from "./index-D66eC3G7.js";
+import { $ as TransferOptions, Bt as EncryptedValue, C as ChainRouter, Ht as FhevmRelayerOptions, K as ZamaSDKEventInput, Mt as TransactionResult, Nt as ClearValue, Pt as DecryptPublicValuesResult, R as TransactionOperation, Rt as EncryptParams, Ut as FhevmRelayerSDK, Z as ShieldOptions, c as GenericStorage, d as WalletAccount, et as UnshieldOptions, i as ZamaConfig, l as GenericProvider, n as RelayerConfig, nt as TransferCallbacks, o as ZamaConfigGeneric, p as WalletAccountListener, rt as UnshieldCallbacks, s as GenericLogger, u as GenericSigner, x as WriteContractConfig, zt as EncryptResult } from "./types-C-WTLcHZ.js";
 import { Address, Hex } from "viem";
 import { z } from "zod/mini";
-import { UserDecryptResults } from "@zama-fhe/relayer-sdk/bundle";
 import { MutationFunctionContext, QueryKey, QueryObserverOptions, skipToken } from "@tanstack/query-core";
 
 //#region src/config/create.d.ts
@@ -39,7 +37,7 @@ declare function resolveStorage(storage?: GenericStorage | undefined, permitStor
 };
 interface ResolvedChainRelayer {
   chain: FheChain;
-  relayer: RelayerConfig;
+  relayerConfig: RelayerConfig;
 }
 declare function resolveChainRelayers(chains: readonly FheChain[], relayers: Readonly<Record<number, RelayerConfig>>): Map<number, ResolvedChainRelayer>;
 //#endregion
@@ -18458,6 +18456,34 @@ declare function isConfidentialTokenValidContract(registry: Address, confidentia
   readonly args: readonly [`0x${string}`];
 };
 //#endregion
+//#region src/query/utils.d.ts
+type StrippedQueryOptionKeys = "gcTime" | "staleTime" | "enabled" | "select" | "refetchInterval" | "refetchOnMount" | "refetchOnWindowFocus" | "refetchOnReconnect" | "retry" | "retryDelay" | "retryOnMount" | "queryFn" | "queryKey" | "queryKeyHashFn" | "initialData" | "initialDataUpdatedAt" | "placeholderData" | "structuralSharing" | "throwOnError" | "meta" | "query" | "pollingInterval";
+/**
+ * Remove TanStack behavioral options from a query config object so only domain
+ * parameters remain for the lower-level factory.
+ *
+ * @example
+ * ```ts
+ * const params = filterQueryOptions({
+ *   query: { enabled: false },
+ *   gcTime: 60_000,
+ *   owner: "0xabc",
+ * });
+ * // => { owner: "0xabc" }
+ * ```
+ */
+declare function filterQueryOptions<TOptions extends Record<string, unknown>>(options: TOptions): Omit<TOptions, StrippedQueryOptionKeys>;
+/**
+ * Stable hash function for query keys.
+ * Sorts object keys recursively and converts bigint values to strings.
+ *
+ * @remarks
+ * bigint values are serialized as decimal strings, so `42n` and `"42"` hash to
+ * the same token when they occupy the same position. This collision is accepted
+ * by design for the current query-key conventions in this package.
+ */
+declare function hashFn(queryKey: readonly unknown[]): string;
+//#endregion
 //#region src/query/factory-types.d.ts
 type RequiredBy<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
 type QueryFactoryOptions<TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<RequiredBy<QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, "queryKey">, "queryFn" | "queryHash" | "queryKeyHashFn" | "throwOnError"> & {
@@ -18469,6 +18495,11 @@ interface MutationFactoryOptions<TMutationKey extends readonly unknown[], TVaria
   onSuccess?: (data: TData, variables: TVariables, onMutateResult: TOnMutateResult, context: MutationFunctionContext) => void;
 }
 //#endregion
+//#region src/query/signer-query-context.d.ts
+interface SignerQueryContext {
+  walletAccount?: WalletAccount;
+}
+//#endregion
 //#region src/query/query-keys.d.ts
 /**
  * Canonical query-key namespace for `@zama-fhe/sdk/query`.
@@ -18672,112 +18703,393 @@ declare const zamaQueryKeys: {
   };
 };
 //#endregion
-//#region src/query/signer-query-context.d.ts
-interface SignerQueryContext {
-  walletAccount?: WalletAccount;
+//#region src/query/invalidation.d.ts
+interface QueryLike {
+  queryKey: readonly unknown[];
+}
+interface QueryFilterLike {
+  queryKey?: readonly unknown[];
+  predicate?: (query: QueryLike) => boolean;
 }
+interface QueryClientLike {
+  invalidateQueries(filters: QueryFilterLike): void | Promise<void>;
+  removeQueries(filters: QueryFilterLike): void;
+}
+declare function invalidateAfterUnwrap(queryClient: QueryClientLike, tokenAddress: Address): void;
+declare function invalidateBalanceQueries(queryClient: QueryClientLike, tokenAddress: Address): void;
+declare function invalidateAfterShield(queryClient: QueryClientLike, tokenAddress: Address): void;
+declare function invalidateAfterUnshield(queryClient: QueryClientLike, tokenAddress: Address): void;
+declare function invalidateAfterUnshieldSettled(queryClient: QueryClientLike, tokenAddress: Address): void;
+declare function invalidateAfterTransfer(queryClient: QueryClientLike, tokenAddress: Address): void;
+declare function invalidateAfterApproveUnderlying(queryClient: QueryClientLike, tokenAddress: Address): void;
+declare function invalidateAfterSetOperator(queryClient: QueryClientLike, tokenAddress: Address): void;
+declare function invalidateWagmiBalanceQueries(queryClient: QueryClientLike): void;
+declare function invalidateWalletLifecycleQueries(queryClient: QueryClientLike): void;
 //#endregion
-//#region src/query/user-decrypt.d.ts
-interface EncryptedInput {
-  encryptedValue: EncryptedValue;
-  contractAddress: Address;
+//#region src/query/token-metadata.d.ts
+/** ERC-20 token metadata returned by {@link tokenMetadataQueryOptions}. */
+interface TokenMetadata {
+  name: string;
+  symbol: string;
+  decimals: number;
 }
-/** Alias for {@link UserDecryptResults}. */
-type DecryptResult = UserDecryptResults;
-declare function decryptValuesQueryOptions(sdk: ZamaSDK, encryptedInputs: EncryptedInput[], signerContext?: SignerQueryContext): QueryFactoryOptions<DecryptResult, Error, DecryptResult, ReturnType<typeof zamaQueryKeys.decryption.encryptedInputs>>;
+interface TokenMetadataQueryConfig {
+  query?: Record<string, unknown>;
+}
+declare function tokenMetadataQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config?: TokenMetadataQueryConfig): QueryFactoryOptions<TokenMetadata, Error, TokenMetadata, ReturnType<typeof zamaQueryKeys.tokenMetadata.token>>;
 //#endregion
-//#region src/credentials/credential-service.d.ts
-/** Configuration for {@link CredentialService}. TTLs are pre-validated by the caller. */
-interface CredentialServiceConfig {
-  relayer: RelayerDispatcher;
-  signer: GenericSigner;
-  /** Transport key pair lifetime in seconds. Pre-validated. */
-  transportKeyPairTTL: number;
-  /** Permit lifetime in days. Pre-validated. */
-  permitTTL: number;
-  /** Backing storage for transport key pairs (and permits if `permitStorage` is omitted). */
-  storage: GenericStorage;
-  /** Optional dedicated storage for permits; defaults to `storage`. */
-  permitStorage?: GenericStorage;
-  /** SDK-wide logger for credential-path diagnostics. */
-  logger: GenericLogger;
+//#region src/query/is-confidential.d.ts
+interface IsConfidentialQueryConfig {
+  query?: Record<string, unknown>;
+}
+declare function isConfidentialQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config?: IsConfidentialQueryConfig): QueryFactoryOptions<boolean, Error, boolean, ReturnType<typeof zamaQueryKeys.isConfidential.token>>;
+declare function isWrapperQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config?: IsConfidentialQueryConfig): QueryFactoryOptions<boolean, Error, boolean, ReturnType<typeof zamaQueryKeys.isWrapper.token>>;
+//#endregion
+//#region src/query/total-supply.d.ts
+interface TotalSupplyQueryConfig {
+  query?: Record<string, unknown>;
 }
+declare function totalSupplyQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config?: TotalSupplyQueryConfig): QueryFactoryOptions<bigint, Error, bigint, ReturnType<typeof zamaQueryKeys.totalSupply.token>>;
+//#endregion
+//#region src/schemas/primitives.d.ts
+declare const checksummedTag: unique symbol;
+/** An EVM address that has been put through `getAddress` (EIP-55 checksum form). */
+type ChecksummedAddress = Address & {
+  readonly [checksummedTag]: true;
+};
+//#endregion
+//#region src/credentials/schemas.d.ts
+declare const StoredTransportKeyPairSchema: z.ZodMiniObject<{
+  publicKey: z.ZodMiniCustom<`0x${string}`, `0x${string}`>;
+  privateKey: z.ZodMiniCustom<`0x${string}`, `0x${string}`>;
+  createdAt: z.ZodMiniNumberFormat;
+  expiresAt: z.ZodMiniNumberFormat;
+}, z.core.$strip>;
+declare const PermissionSchema: z.ZodMiniObject<{
+  keypairPublicKey: z.ZodMiniCustom<`0x${string}`, `0x${string}`>;
+  contractAddresses: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniCustom<`0x${string}`, `0x${string}`>, z.ZodMiniTransform<ChecksummedAddress, `0x${string}`>>>;
+  serializedPermit: z.ZodMiniObject<{
+    version: z.ZodMiniNumberFormat;
+    eip712: z.ZodMiniObject<{
+      domain: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>;
+      primaryType: z.ZodMiniOptional<z.ZodMiniString<string>>;
+      types: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniObject<{
+        name: z.ZodMiniString<string>;
+        type: z.ZodMiniString<string>;
+      }, z.core.$strip>>>;
+      message: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>;
+    }, z.core.$strip>;
+    signature: z.ZodMiniCustom<`0x${string}`, `0x${string}`>;
+    signerAddress: z.ZodMiniPipe<z.ZodMiniCustom<`0x${string}`, `0x${string}`>, z.ZodMiniTransform<ChecksummedAddress, `0x${string}`>>;
+  }, z.core.$strip>;
+  startTimestamp: z.ZodMiniNumberFormat;
+  durationDays: z.ZodMiniNumberFormat;
+}, z.core.$strip>;
+//#endregion
+//#region src/credentials/types.d.ts
 /**
- * Single facade coordinating the keypair vault and the permission store.
+ * Serialized transport key pair — ML-KEM public + private key as hex, the shape
+ * we persist and hand to the decrypt path. Mirrors `@fhevm/sdk`'s
+ * `serializeTransportKeyPair` output; the private half is plaintext, so treat it
+ * as sensitive.
+ */
+interface SerializedTransportKeyPair {
+  publicKey: Hex;
+  privateKey: Hex;
+}
+/** Persisted transport key pair entry with a bounded lifetime. */
+type StoredTransportKeyPair = z.infer<typeof StoredTransportKeyPairSchema>;
+/**
+ * A signed EIP-712 permit binding a signer (and optional delegator) to a set of
+ * contract addresses for a bounded time window. Wraps the serialized `@fhevm/sdk`
+ * permit ({@link SerializedPermit}) alongside the scope/coverage metadata the
+ * permission store indexes on.
+ */
+type Permission = z.infer<typeof PermissionSchema>;
+/**
+ * Credentials resolved for a decrypt operation: the transport key pair plus the
+ * permits covering the requested contracts. A live, in-memory bundle — not a
+ * storage record. {@link resolvePermit} extracts one {@link ResolvedPermit} from
+ * it per contract.
+ */
+interface SerializedTransportKeyPairWithPermissions {
+  readonly keypair: SerializedTransportKeyPair;
+  readonly permissions: readonly Permission[];
+}
+//#endregion
+//#region src/wrappers-registry.d.ts
+/**
+ * Default wrappers registry addresses for known chains.
+ * Only includes chains where a registry is deployed (excludes Hardhat).
  *
- * `CredentialService` is the only credentials object held by `ZamaSDK`. It accepts identity
- * transitions via `handleWalletAccountChange`.
+ * @deprecated Read `registryAddress` from the chain presets instead (e.g.
+ * `sepolia.registryAddress`). Will be removed in the next major version.
  */
-declare class CredentialService {
+declare const DefaultRegistryAddresses: Record<number, Address>;
+/** Configuration for {@link WrappersRegistry}. */
+interface WrappersRegistryConfig {
+  /** Read-only chain provider used for every registry lookup. */
+  provider: GenericProvider;
+  /**
+   * Per-chain registry address overrides, merged on top of
+   * {@link DefaultRegistryAddresses}. Use this to supply a registry
+   * address for custom or local chains (e.g. Hardhat).
+   *
+   * @example
+   * ```ts
+   * new WrappersRegistry({
+   *   provider,
+   *   registryAddresses: { [31337]: "0xYourHardhatRegistry" },
+   * });
+   * ```
+   */
+  registryAddresses?: Record<number, Address>;
+  /**
+   * How long cached registry results remain valid, in seconds.
+   * Default: `86400` (24 hours).
+   */
+  registryTTL?: number;
+}
+/** Options for {@link WrappersRegistry.listPairs}. */
+interface ListPairsOptions {
+  /** Page number (1-indexed). Default: `1`. */
+  page?: number;
+  /** Number of items per page. Default: `100`. */
+  pageSize?: number;
+  /**
+   * When `true`, fetches on-chain metadata (name, symbol, decimals) for both
+   * the ERC-20 and confidential token, plus totalSupply for the ERC-20.
+   * Default: `false`.
+   */
+  metadata?: boolean;
+}
+/**
+ * High-level interface for the on-chain token wrappers registry.
+ *
+ * Uses the configured {@link GenericProvider} to resolve the correct registry
+ * contract address for the current chain and exposes typed read helpers for
+ * every registry query. Results are cached in memory with a configurable TTL
+ * (default 24 hours).
+ *
+ * @example
+ * ```ts
+ * const registry = new WrappersRegistry({ provider });
+ *
+ * // Paginated listing
+ * const page1 = await registry.listPairs({ page: 1, pageSize: 20 });
+ *
+ * // Structured lookups
+ * const result = await registry.getConfidentialToken(erc20Address);
+ * if (result) console.log(result.confidentialTokenAddress);
+ *
+ * // Force refresh
+ * registry.refresh();
+ * ```
+ */
+declare class WrappersRegistry {
   #private;
-  constructor(config: CredentialServiceConfig);
+  readonly provider: GenericProvider;
+  constructor(config: WrappersRegistryConfig);
   /**
-   * Resolve a keypair and permissions covering `contracts`, minimizing wallet
-   * prompts by reusing or widening existing permits where possible. Empty
-   * `contracts` warms the keypair without prompting.
+   * Synchronous lookup of the registry address for a given chain ID.
+   * Returns `undefined` if no address is configured for that chain.
+   */
+  getAddress(chainId: number): Address | undefined;
+  /**
+   * Force-invalidate the in-memory cache. The next call to any read method
+   * will fetch fresh data from the chain.
+   */
+  refresh(): void;
+  /**
+   * The cache TTL in milliseconds.
+   * Exposed so query option factories can set a matching `staleTime`.
+   */
+  get ttlMs(): number;
+  /**
+   * Resolve the registry contract address for the current chain.
    *
-   * @returns The resolved keypair and permits covering the requested contracts.
-   * @throws if the user rejects a wallet signature prompt. {@link SigningRejectedError}
-   * @throws if signing fails for any other reason. {@link SigningFailedError}
+   * Priority: `registryAddresses[chainId]` \> built-in default.
+   *
+   * @returns The registry contract address for the connected chain.
+   * @throws if no address is configured for the chain. {@link ConfigurationError}
    */
-  grantPermit(contracts: readonly Address[], delegator?: Address): Promise<StoredTransportKeyPairWithPermits>;
+  getRegistryAddress(): Promise<Address>;
   /**
-   * Pure store lookup: are stored permits sufficient to cover `contracts`? No wallet prompt.
+   * List token wrapper pairs with page-based pagination.
    *
-   * @returns `true` if cached permits cover all requested contracts (vacuously
-   *   true for an empty list); `false` if no keypair exists or coverage is
-   *   incomplete.
+   * Internally maps to `getTokenConfidentialTokenPairsSlice` on-chain.
+   *
+   * @param options - Pagination and enrichment options.
+   * @returns A {@link PaginatedResult} of pairs.
+   *
+   * @example
+   * ```ts
+   * const result = await registry.listPairs({ page: 1, pageSize: 20 });
+   * console.log(`${result.total} pairs, showing page ${result.page}`);
+   *
+   * // With on-chain metadata
+   * const withMeta = await registry.listPairs({ metadata: true, pageSize: 10 });
+   * for (const pair of withMeta.items) {
+   *   console.log(pair.underlying.symbol, "→", pair.confidential.symbol);
+   * }
+   * ```
    */
-  hasPermit(contracts: readonly Address[], delegator?: Address): Promise<boolean>;
+  listPairs(options: ListPairsOptions & {
+    metadata: true;
+  }): Promise<PaginatedResult<TokenWrapperPairWithMetadata>>;
+  listPairs(options?: ListPairsOptions): Promise<PaginatedResult<TokenWrapperPair>>;
   /**
-   * Wipe FHE permits for the current signer.
+   * Look up the confidential token for a given plain ERC-20 address.
    *
-   * - With no argument: every permit referencing this signer is removed across
-   *   all chains and delegators. The keypair survives — use
-   *   {@link clearCredentials} to also wipe the keypair.
-   * - With a contract list: every signed permit in the direct-decrypt scope
-   *   (current chain) whose immutable payload touches any listed address is
-   *   removed. Delegated permits are not touched in this mode.
+   * @param tokenAddress - The plain ERC-20 token address.
+   * @returns The lookup result, or `null` if the token has never been registered.
+   *   **Note:** revoked tokens (registered then invalidated) return a non-null result
+   *   with `isValid: false`. Check `result.isValid` explicitly rather than using
+   *   `if (result)` to guard against processing revoked tokens.
    *
-   * @throws if reading the signer address fails. {@link SigningFailedError}
+   * @example
+   * ```ts
+   * const result = await registry.getConfidentialToken(usdcAddress);
+   * if (result?.isValid) {
+   *   console.log(result.confidentialTokenAddress);
+   * }
+   * ```
    */
-  revokePermits(contracts?: readonly Address[]): Promise<void>;
+  getConfidentialToken(tokenAddress: Address): Promise<{
+    confidentialTokenAddress: Address;
+    isValid: boolean;
+  } | null>;
   /**
-   * Wipe the keypair for the current signer and cascade-delete every
-   * permission referencing it across all chains and delegators.
+   * Reverse lookup — find the plain ERC-20 for a given confidential token.
    *
-   * @throws if reading the signer address fails. {@link SigningFailedError}
+   * @param confidentialTokenAddress - The confidential token address.
+   * @returns The lookup result, or `null` if no pair is registered.
+   *
+   * @example
+   * ```ts
+   * const result = await registry.getUnderlyingToken(cUsdcAddress);
+   * if (result) {
+   *   console.log(result.tokenAddress, result.isValid);
+   * }
+   * ```
    */
-  clearCredentials(): Promise<void>;
+  getUnderlyingToken(confidentialTokenAddress: Address): Promise<{
+    tokenAddress: Address;
+    isValid: boolean;
+  } | null>;
   /**
-   * Warm the signer transport key pair cache for a known address.
+   * Fetch all token wrapper pairs from the registry.
    *
-   * Best-effort prefetch primitive: correctness still comes from `grantPermit`,
-   * which lazily creates the transport key pair when needed. Errors (storage failure,
-   * relayer 4xx, missing Worker in SSR) are **not** swallowed here — the caller
-   * decides whether to log, ignore, or surface them.
+   * @returns All registered `TokenWrapperPair` entries.
    */
-  warmTransportKeyPair(address: Address): Promise<void>;
+  getTokenPairs(): Promise<readonly TokenWrapperPair[]>;
   /**
-   * Apply a wallet account transition.
+   * Get the total number of token wrapper pairs.
    *
-   * Address change clears persisted credentials for the previous account.
-   * Chain-only changes keep credentials intact because permits are chain-scoped
-   * already and stale decrypt plaintext is cleared by `ZamaSDK`.
+   * @returns The count as a bigint.
    */
-  handleWalletAccountChange(prev?: {
-    address: Address;
-  }, next?: {
-    address: Address;
-  }): Promise<void>;
-}
-//#endregion
-//#region src/errors/base.d.ts
-/**
- * Typed error codes thrown by the SDK.
- * Use `error.code` or `instanceof` to programmatically handle specific failure modes.
- *
- * @example
+  getTokenPairsLength(): Promise<bigint>;
+  /**
+   * Fetch a range of token wrapper pairs (paginated by index).
+   *
+   * @param fromIndex - Start index (inclusive).
+   * @param toIndex - End index (exclusive).
+   * @returns The slice of `TokenWrapperPair` entries.
+   */
+  getTokenPairsSlice(fromIndex: bigint, toIndex: bigint): Promise<readonly TokenWrapperPair[]>;
+  /**
+   * Fetch a single token wrapper pair by index.
+   *
+   * @param index - Zero-based pair index.
+   * @returns The `TokenWrapperPair` at that index.
+   */
+  getTokenPair(index: bigint): Promise<TokenWrapperPair>;
+  /**
+   * Look up the confidential token address for a given plain ERC-20 token.
+   *
+   * @param tokenAddress - The plain ERC-20 token address.
+   * @returns A tuple `[isValid, confidentialTokenAddress]`. `isValid` is `true` only for a
+   *   registered, non-revoked wrapper. The address is the zero address when no pair is registered.
+   *   A non-zero address with `isValid=false` means the wrapper was registered but later revoked.
+   */
+  getConfidentialTokenAddress(tokenAddress: Address): Promise<readonly [boolean, Address]>;
+  /**
+   * Reverse lookup — find the plain ERC-20 for a given confidential token.
+   *
+   * @param confidentialTokenAddress - The confidential token address.
+   * @returns A tuple `[isValid, tokenAddress]`. `isValid` is `true` only for a registered,
+   *   non-revoked wrapper. The address is the zero address when no pair is registered.
+   *   A non-zero address with `isValid=false` means the wrapper was registered but later revoked.
+   */
+  getTokenAddress(confidentialTokenAddress: Address): Promise<readonly [boolean, Address]>;
+  /**
+   * Check whether a confidential token is registered and valid.
+   *
+   * @param confidentialTokenAddress - The confidential token address to check.
+   * @returns `true` if the token is a known valid wrapper in the registry.
+   */
+  isConfidentialTokenValid(confidentialTokenAddress: Address): Promise<boolean>;
+}
+//#endregion
+//#region src/query/wrapper-discovery.d.ts
+interface WrapperDiscoveryQueryConfig {
+  /**
+   * Address of any confidential token you control.
+   * Used to scope the query cache key and to gate whether the query
+   * is enabled — it does not affect which wrapper the registry returns.
+   */
+  tokenAddress?: Address;
+  /**
+   * The ERC-20 token address to discover the confidential wrapper for.
+   * The registry is resolved automatically from chain config.
+   */
+  erc20Address?: Address;
+  /**
+   * The resolved registry contract address for the current chain.
+   * Included in the query key so that switching chains invalidates
+   * stale cached results. Pass `undefined` when the chain ID is not
+   * yet known — the query will be disabled.
+   */
+  registryAddress?: Address;
+  query?: Record<string, unknown>;
+}
+declare function wrapperDiscoveryQueryOptions(registry: WrappersRegistry, config: WrapperDiscoveryQueryConfig): QueryFactoryOptions<Address | null, Error, Address | null, ReturnType<typeof zamaQueryKeys.wrapperDiscovery.token>>;
+//#endregion
+//#region src/query/underlying-allowance.d.ts
+interface UnderlyingAllowanceQueryConfig {
+  owner?: Address;
+  query?: Record<string, unknown>;
+}
+declare function underlyingAllowanceQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config: UnderlyingAllowanceQueryConfig): QueryFactoryOptions<bigint, Error, bigint, ReturnType<typeof zamaQueryKeys.underlyingAllowance.scope>>;
+//#endregion
+//#region src/query/pending-unshield.d.ts
+interface PendingUnshieldQueryConfig {
+  query?: Record<string, unknown>;
+}
+/**
+ * Query options for reading the unwrap tx hash of an unshield that was
+ * interrupted between its two phases (returns `null` if none is pending).
+ *
+ * Backed by {@link ZamaSDK} storage via `WrappedToken.getPendingUnshield()`.
+ * `staleTime: 0` so the value reflects storage on mount; the unshield/unwrap
+ * mutations also invalidate this key on success.
+ */
+declare function pendingUnshieldQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config?: PendingUnshieldQueryConfig): QueryFactoryOptions<Hex | null, Error, Hex | null, ReturnType<typeof zamaQueryKeys.pendingUnshield.token>>;
+//#endregion
+//#region src/query/confidential-is-operator.d.ts
+interface ConfidentialIsOperatorQueryConfig {
+  holder?: Address;
+  spender?: Address;
+  query?: Record<string, unknown>;
+}
+declare function confidentialIsOperatorQueryOptions(sdk: ZamaSDK, tokenAddress: Address | undefined, config: ConfidentialIsOperatorQueryConfig): QueryFactoryOptions<boolean, Error, boolean, ReturnType<typeof zamaQueryKeys.confidentialIsOperator.scope>>;
+//#endregion
+//#region src/errors/base.d.ts
+/**
+ * Typed error codes thrown by the SDK.
+ * Use `error.code` or `instanceof` to programmatically handle specific failure modes.
+ *
+ * @example
  * ```ts
  * try {
  *   await token.confidentialTransfer("0xTo", 100n);
@@ -18799,9 +19111,7 @@ declare const ZamaErrorCode: {
   readonly NoCiphertext: "NO_CIPHERTEXT"; /** Relayer HTTP request failed. */
   readonly RelayerRequestFailed: "RELAYER_REQUEST_FAILED"; /** The configured signer/account is not entitled (ACL) to decrypt this encrypted value. Don't retry — wait for a grant. */
   readonly NotEntitled: "NOT_ENTITLED"; /** The consumer's RPC provider rate-limited an on-chain read (e.g. HTTP 429 / JSON-RPC -32005). Retryable. */
-  readonly RpcRateLimited: "RPC_RATE_LIMITED"; /** A worker operation exceeded its configured timeout; the worker is recycled by default. Retryable. */
-  readonly OperationTimeout: "OPERATION_TIMEOUT"; /** An in-flight worker operation was aborted as collateral of another operation's timeout recycle. Retryable. */
-  readonly WorkerRecycled: "WORKER_RECYCLED"; /** SDK configuration is invalid (e.g. forbidden chain ID, unsupported type). */
+  readonly RpcRateLimited: "RPC_RATE_LIMITED"; /** SDK configuration is invalid (e.g. forbidden chain ID, unsupported type). */
   readonly Configuration: "CONFIGURATION"; /** Delegation cannot target self (delegate === msg.sender). */
   readonly DelegationSelfNotAllowed: "DELEGATION_SELF_NOT_ALLOWED"; /** Only one delegate/revoke per (delegator, delegate, contract) per block. */
   readonly DelegationCooldown: "DELEGATION_COOLDOWN"; /** No active delegation found for this (delegator, delegate, contract) tuple. */
@@ -19010,11 +19320,14 @@ declare class RelayerRequestFailedError extends ZamaError {
   readonly retryAfter: number | undefined;
   /**
    * Whether the request may be safely retried. `true` for relayer back-pressure
-   * (HTTP 429); pair with {@link retryAfter} for the server's suggested delay.
+   * (HTTP 429) — pair with {@link retryAfter} for the server's suggested delay —
+   * and for a relayer timeout (which carries no status but is safe to retry, via
+   * the `retryable` option). `false` for terminal failures (e.g. a 4xx/5xx).
    */
   readonly retryable: boolean;
   constructor(message: string, statusCode?: number, options?: ErrorOptions & {
     retryAfter?: number;
+    retryable?: boolean;
   });
 }
 /** SDK configuration is invalid (e.g. forbidden chain ID, unsupported type). */
@@ -19144,79 +19457,6 @@ declare class TransactionRevertedError extends ZamaError {
   constructor(message: string, options?: ErrorOptions);
 }
 //#endregion
-//#region src/errors/timeout.d.ts
-/**
- * A worker operation (encrypt / decrypt / EIP-712 / key fetch) did not complete
- * within its configured timeout — typically a stuck relayer or WASM call. On the
- * Node pool the SDK **recycles the affected worker** (terminating the hung
- * thread) so it self-heals; the operation itself is **retryable**.
- *
- * Configure the bound (seconds) via `node({ operationTimeout })`. Distinct from a
- * decryption/entitlement failure — a timeout is an infrastructure/latency
- * condition, so it no longer collapses into {@link DecryptionFailedError}.
- *
- * @example
- * ```ts
- * try {
- *   await sdk.decryption.decryptValues([{ encryptedValue, contractAddress }]);
- * } catch (e) {
- *   if (e instanceof WorkerTimeoutError) {
- *     // retry (the worker was recycled); consider raising operationTimeout
- *   }
- * }
- * ```
- */
-declare class WorkerTimeoutError extends ZamaError {
-  /**
-   * The worker operation that timed out. This is the internal worker op code
-   * (e.g. `USER_DECRYPT`, `ENCRYPT`), not the public SDK method name.
-   */
-  readonly operation: string;
-  /** The configured timeout that was exceeded, in **seconds** (the SDK's duration unit). */
-  readonly timeout: number;
-  /** Wall-clock time the operation ran before being abandoned, in **seconds** (may be fractional). */
-  readonly elapsed: number;
-  /** Label of the worker that stalled, when known (e.g. `node-worker-2`). */
-  readonly worker: string | undefined;
-  constructor(args: {
-    operation: string;
-    timeout: number;
-    elapsed: number;
-    worker?: string;
-  }, options?: ErrorOptions);
-}
-/**
- * An in-flight worker operation was aborted as **collateral** when its worker was
- * recycled — the worker was torn down to recover from *another* operation's
- * timeout (Node pool self-healing), not because this operation itself timed out.
- *
- * The operation never reached a verdict, so it is **retryable**: the next call
- * lazily re-inits a fresh worker. It is intentionally distinct from
- * {@link WorkerTimeoutError} (this op did not exceed its own bound) and from
- * {@link DecryptionFailedError} (nothing actually failed to decrypt) — so a
- * consumer can retry it instead of surfacing a terminal failure.
- *
- * @example
- * ```ts
- * matchZamaError(error, {
- *   WORKER_RECYCLED: () => retry(), // transient: the worker was replaced
- * });
- * ```
- */
-declare class WorkerRecycledError extends ZamaError {
-  /**
-   * The worker operation that was aborted. This is the internal worker op code
-   * (e.g. `USER_DECRYPT`, `ENCRYPT`), not the public SDK method name.
-   */
-  readonly operation: string;
-  /** Label of the recycled worker, when known (e.g. `node-worker-2`). */
-  readonly worker: string | undefined;
-  constructor(args: {
-    operation: string;
-    worker?: string;
-  }, options?: ErrorOptions);
-}
-//#endregion
 //#region src/errors/match.d.ts
 /**
  * Identity type that fails to instantiate unless `T` maps every code to a `ZamaError`.
@@ -19242,8 +19482,6 @@ type ErrorForCode = Complete<{
   [ZamaErrorCode.RelayerRequestFailed]: RelayerRequestFailedError;
   [ZamaErrorCode.NotEntitled]: NotEntitledError;
   [ZamaErrorCode.RpcRateLimited]: RpcRateLimitError;
-  [ZamaErrorCode.OperationTimeout]: WorkerTimeoutError;
-  [ZamaErrorCode.WorkerRecycled]: WorkerRecycledError;
   [ZamaErrorCode.Configuration]: ConfigurationError;
   [ZamaErrorCode.DelegationSelfNotAllowed]: DelegationSelfNotAllowedError;
   [ZamaErrorCode.DelegationCooldown]: DelegationCooldownError;
@@ -19284,1198 +19522,1325 @@ declare function matchZamaError<R>(error: unknown, handlers: { [K in ZamaErrorCo
   _?: (error: unknown) => R;
 }): R | undefined;
 //#endregion
-//#region src/services/caching-service.d.ts
-/**
- * Storage-backed cache for decrypted FHE plaintext values.
- *
- * Each entry is keyed by `(requester, contractAddress, handle)` so different
- * signers cannot read each other's cached decryptions.
- */
-declare class CachingService {
-  #private;
-  constructor(storage: GenericStorage, logger: GenericLogger);
-  get(requester: Address, contractAddress: Address, encryptedValue: EncryptedValue): Promise<ClearValue | null>;
-  set(requester: Address, contractAddress: Address, encryptedValue: EncryptedValue, value: ClearValue): Promise<void>;
-  delete(requester: Address, contractAddress: Address, encryptedValue: EncryptedValue): Promise<void>;
-  clearForRequester(requester: Address): Promise<void>;
-  clearAll(): Promise<void>;
-}
-//#endregion
-//#region src/services/delegation-service.d.ts
-declare class DelegationService {
-  #private;
-  constructor({
-    provider,
-    relayer,
-    emitEvent,
-    logger
-  }: {
-    provider: GenericProvider;
-    relayer: RelayerDispatcher;
-    logger: GenericLogger;
-    emitEvent?: (input: ZamaSDKEventInput, tokenAddress?: Address) => void;
-  });
-  delegateDecryption(signer: GenericSigner, {
-    contractAddress,
-    delegateAddress,
-    delegatorAddress,
-    expirationDate
-  }: {
-    contractAddress: Address;
-    delegateAddress: Address;
-    delegatorAddress: Address;
-    expirationDate?: Date;
-  }): Promise<TransactionResult>;
-  revokeDelegation(signer: GenericSigner, {
-    contractAddress,
-    delegateAddress,
-    delegatorAddress
-  }: {
-    contractAddress: Address;
-    delegateAddress: Address;
-    delegatorAddress: Address;
-  }): Promise<TransactionResult>;
-  isDelegated(params: {
-    contractAddress: Address;
-    delegatorAddress: Address;
-    delegateAddress: Address;
-  }): Promise<boolean>;
-  getDelegationExpiry({
-    contractAddress,
-    delegatorAddress,
-    delegateAddress
-  }: {
-    contractAddress: Address;
-    delegatorAddress: Address;
-    delegateAddress: Address;
-  }): Promise<bigint>;
-  findInactiveDelegations(contractAddresses: readonly Address[], delegatorAddress: Address, delegateAddress: Address): Promise<Map<Address, DelegationNotFoundError | DelegationExpiredError>>;
-  assertDelegationActive(contractAddress: Address, delegatorAddress: Address, delegateAddress: Address): Promise<void>;
-}
-//#endregion
-//#region src/services/decryption-service.d.ts
-/** Options shared by the delegated-decrypt entry points. */
-interface DelegatedDecryptOptions {
+//#region src/token/token.d.ts
+/** Options for {@link Token.batchDecryptBalancesAs}. */
+interface BatchDecryptAsOptions {
+  /** The address of the account that delegated decryption rights. */
+  delegatorAddress: Address;
+  /** Pre-fetched encrypted values. When omitted, they are fetched from the chain. */
+  encryptedValues?: EncryptedValue[];
   /**
-   * Ride out the gateway propagation window: when a just-granted delegation
-   * has not yet synced, the delegated decrypt is retried (bounded, ~30s) until
-   * it lands instead of throwing {@link DelegationNotPropagatedError}. Defaults
-   * to `true`. Pass `false` to fail fast on the first not-propagated response.
+   * The account whose on-chain balance to read. Defaults to the delegator
+   * address, which is the common case (the delegator grants permission to
+   * decrypt their own balance). Only set this when the account differs
+   * from the delegator.
+   *
+   * Matches the `account` parameter of `confidentialBalanceOf(account)` on-chain.
    */
-  waitForPropagation?: boolean;
-}
-interface BatchDecryptItem {
-  encryptedValue: EncryptedValue;
-  contractAddress: Address;
-  value?: ClearValue;
-  error?: ZamaError;
-}
-interface BatchDecryptResult {
-  items: BatchDecryptItem[];
+  accountAddress?: Address;
+  /** Maximum number of concurrent decrypt calls. Default: 10. */
+  maxConcurrency?: number;
+  /** Called when decryption fails for a single token. Return a fallback bigint. */
+  onError?: (error: Error, address: Address) => bigint;
 }
-declare class DecryptionService {
-  #private;
-  constructor({
-    cache,
-    credentialService,
-    delegationService,
-    relayer,
-    emitEvent
-  }: {
-    cache: CachingService;
-    credentialService: CredentialService;
-    delegationService: DelegationService;
-    relayer: RelayerDispatcher;
-    emitEvent: (input: ZamaSDKEventInput) => void;
-  });
-  userDecrypt(handles: EncryptedInput[], signerAddress: Address): Promise<Record<EncryptedValue, ClearValue>>;
-  delegatedUserDecrypt(encryptedValues: EncryptedInput[], delegatorAddress: Address, delegateAddress: Address, accountAddress: Address, options?: DelegatedDecryptOptions): Promise<Record<EncryptedValue, ClearValue>>;
-  delegatedBatchDecryptHandlesAs({
-    encryptedInputs,
-    delegatorAddress,
-    delegateAddress,
-    accountAddress,
-    maxConcurrency,
-    waitForPropagation
-  }: {
-    encryptedInputs: EncryptedInput[];
-    delegatorAddress: Address;
-    delegateAddress: Address;
-    accountAddress: Address;
-    maxConcurrency?: number;
-    waitForPropagation?: boolean;
-  }): Promise<BatchDecryptResult>;
+/** Result of {@link Token.batchBalancesOf}. */
+interface BatchBalancesResult {
+  /** Successfully decrypted balances, keyed by token address. */
+  results: Map<Address, bigint>;
+  /** Per-token errors for tokens that failed to decrypt. */
+  errors: Map<Address, ZamaError>;
 }
-//#endregion
-//#region src/namespaces/decryption.d.ts
 /**
- * Public namespace for FHE decryption — the canonical way to decrypt.
- *
- * Exposed as `sdk.decryption`. Prefer these methods over the low-level
- * `sdk.relayer.userDecrypt` / `delegatedUserDecrypt` / `publicDecrypt`: they
- * assemble the credential bundle (transport key pair, EIP-712 permit) for you,
- * cache results, and wrap relayer errors. Reach for `sdk.relayer.*` only when
- * you must control credential assembly by hand.
+ * High-level interface for an ERC-7984 confidential token.
+ * Hides FHE complexity (encryption, decryption, EIP-712 signing) behind
+ * familiar ERC-20-like methods.
  *
- * Owns the SDK-level guards (signer requirement on
- * `decryptValues` and `delegatedDecryptValues`, empty-array
- * short-circuit on `decryptPublicValues`, relayer error wrapping) and delegates the
- * actual work to the internal {@link DecryptionService} or the relayer directly for
- * `decryptPublicValues`.
+ * For ERC-7984 wrappers (shield/unshield), use {@link WrappedToken} instead —
+ * it extends `Token` with wrapper-specific operations.
  *
- * **Mixed signer requirement:** `decryptValues` and
- * `delegatedDecryptValues` need a configured signer; `decryptPublicValues`
- * does not. Each method documents its requirement in its JSDoc.
+ * Decryption, credentials, caching, and event emission are handled by the
+ * owning {@link ZamaSDK} — this class only exposes token-scoped helpers
+ * that delegate to `sdk.decryption.decryptValues` and `sdk.permits.grantPermit`.
  */
-declare class Decryption {
+declare class Token {
   #private;
-  /** @internal */
-  constructor(opts: {
-    signer: GenericSigner | undefined;
-    provider: GenericProvider;
-    relayer: RelayerDispatcher;
-    decryptionService: DecryptionService | undefined;
-  });
+  readonly sdk: ZamaSDK;
+  readonly address: Address;
+  constructor(sdk: ZamaSDK, address: Address);
+  /** Read the token name from the contract. */
+  name(): Promise<string>;
+  /** Read the token symbol from the contract. */
+  symbol(): Promise<string>;
+  /** Read the token decimals from the contract. */
+  decimals(): Promise<number>;
   /**
-   * Decrypt one or more FHE encrypted values. Results are cached — repeated calls
-   * for the same encrypted value skip the relayer round-trip.
-   *
-   * Zero encrypted values are mapped to `0n` without hitting the relayer.
-   * Events (`DecryptStart/End/Error`) are emitted uniformly.
-   * Relayer errors are wrapped into typed SDK errors.
-   *
-   * @param encryptedInput - Encrypted values to decrypt, each paired with its contract address.
-   * @returns A record mapping each encrypted value to its decrypted clear-text value.
-   * @throws if no signer is configured. {@link SignerNotConfiguredError}
-   * @throws if signer and provider are on different chains. {@link ChainMismatchError}
+   * ERC-165 check for {@link ERC7984_INTERFACE_ID} support.
    *
-   * @example
-   * ```ts
-   * const values = await sdk.decryption.decryptValues([
-   *   { encryptedValue: balance, contractAddress: cUSDT },
-   * ]);
-   * console.log(values[balance]); // 1000n
-   * ```
+   * @returns `true` if the contract implements the ERC-7984 confidential token interface.
    */
-  decryptValues(encryptedInput: EncryptedInput[]): Promise<Record<EncryptedValue, ClearValue>>;
+  isConfidential(): Promise<boolean>;
   /**
-   * Decrypt one or more FHE encrypted values using delegated credentials.
+   * ERC-165 check for IERC7984ERC20Wrapper support.
    *
-   * Mirrors {@link decryptValues} with delegated credentials — same caching and
-   * zero-value short-circuit. Before reading from cache or calling the relayer,
-   * every non-zero encrypted value's contract must have an active delegation from the
-   * delegator to the connected signer; missing or expired delegations fail fast.
+   * @returns `true` if the contract implements the ERC-7984 wrapper interface
+   *   ({@link ERC7984_WRAPPER_INTERFACE_ID}, `0x1f1c62b2`).
+   */
+  isWrapper(): Promise<boolean>;
+  /**
+   * Decrypt and return the plaintext balance for the given owner.
+   * Acquires FHE credentials via a wallet signature if none are cached.
    *
-   * @param encryptedInputs - FHE encrypted values paired with their contract addresses.
-   * @param delegatorAddress - The address that granted delegation rights.
-   * @param accountAddress - Address used as the cache key's "requester"
-   *   dimension. Defaults to `delegatorAddress`. Pass the actual account address
-   *   when decrypting on behalf of someone whose balance is stored under a
-   *   different address (e.g. `decryptBalanceAs` with an explicit `accountAddress`).
-   * @param options - Delegated-decrypt options. By default the call rides out the
-   *   gateway propagation window ({@link DelegatedDecryptOptions.waitForPropagation});
-   *   pass `{ waitForPropagation: false }` to fail fast instead.
-   * @returns Map of encrypted value → clear-text value.
+   * @param owner - Balance owner address.
+   * @returns The decrypted plaintext balance as a bigint.
+   * @throws if FHE decryption fails. {@link DecryptionFailedError}
    *
    * @example
    * ```ts
-   * const values = await sdk.decryption.delegatedDecryptValues([
-   *   { encryptedValue: balance, contractAddress: tokenAddr },
-   * ], delegatorAddr);
-   * console.log(values[balance]); // 1000n
+   * const balance = await token.balanceOf("0xOwner");
    * ```
    */
-  delegatedDecryptValues(encryptedInputs: EncryptedInput[], delegatorAddress: Address, accountAddress?: Address, options?: DelegatedDecryptOptions): Promise<Record<EncryptedValue, ClearValue>>;
+  balanceOf(owner: Address): Promise<bigint>;
   /**
-   * Publicly decrypt one or more FHE encrypted values.
-   *
-   * Signer-independent: works without a configured signer.
-   * Returns the decryption proof alongside the clear-text values so callers
-   * can submit on-chain finalization transactions (e.g. `finalizeUnwrap`).
+   * Return the raw encrypted balance without decrypting.
    *
-   * @param encryptedValues - FHE encrypted values to decrypt publicly.
-   * @returns Clear-text values, ABI-encoded values, and the decryption proof.
+   * @param owner - Balance owner address.
+   * @returns The encrypted balance as a hex string.
    *
    * @example
    * ```ts
-   * const { clearValues, decryptionProof, abiEncodedClearValues } =
-   *   await sdk.decryption.decryptPublicValues([encryptedValue]);
+   * const encryptedValue = await token.confidentialBalanceOf("0xOwner");
    * ```
    */
-  decryptPublicValues(encryptedValues: EncryptedValue[]): Promise<PublicDecryptResult>;
+  confidentialBalanceOf(owner: Address): Promise<EncryptedValue>;
   /**
-   * Batch-decrypt delegated encrypted values with per-entry error isolation.
+   * Decrypt the balance of a delegator using delegated decryption credentials.
+   * The connected signer acts as the delegatee who has been granted permission
+   * by the delegator to decrypt their balance.
    *
-   * Attempts a single batch request first. If the batch fails with a non-fatal
-   * error (e.g. one entry is invalid), falls back to per-entry decryption so
-   * healthy entries still resolve. Each item in the result carries either a
-   * decrypted value or an error — callers decide how to surface partial failures.
+   * Clear values are cached in storage keyed by `(account, token, encryptedValue)`.
+   * Because every on-chain balance change produces a new encrypted value,
+   * stale cache entries are never served. Cache write failures are silently
+   * ignored — they do not affect the returned value.
    *
-   * @param encryptedInputs - FHE encrypted values paired with their contract addresses.
-   * @param delegatorAddress - The address that granted delegation rights.
-   * @param accountAddress - The account on whose behalf decryption is performed. Defaults to `delegatorAddress`.
-   * @param maxConcurrency - Maximum parallel decrypt calls during per-entry fallback.
-   * @param waitForPropagation - Ride out the gateway propagation window on the
-   *   initial batch attempt (default `true`). See {@link DelegatedDecryptOptions.waitForPropagation}.
-   * @returns Per-entry results, each with a value or an error.
-   * @throws if no signer is configured. {@link SignerNotConfiguredError}
-   * @throws if signer and provider are on different chains. {@link ChainMismatchError}
+   * @param delegatorAddress - The address of the account that delegated decryption rights.
+   * @param accountAddress - The account whose on-chain balance to read. Defaults
+   *   to the delegator address.
+   * @returns The decrypted plaintext balance as a bigint.
+   * @throws if no active delegation exists. {@link DelegationNotFoundError}
+   * @throws if the delegation has expired. {@link DelegationExpiredError}
+   * @throws if delegated decryption fails. {@link DecryptionFailedError}
    *
    * @example
    * ```ts
-   * const result = await sdk.decryption.delegatedBatchDecryptValues({
-   *   encryptedInputs: [
-   *     { encryptedValue: encryptedValue1, contractAddress: tokenA },
-   *     { encryptedValue: encryptedValue2, contractAddress: tokenB },
-   *   ],
+   * const balance = await token.decryptBalanceAs({
    *   delegatorAddress: "0xDelegator",
-   *   maxConcurrency: 5,
    * });
-   * for (const item of result.items) {
-   *   if (item.error) console.error(item.encryptedValue, item.error);
-   *   else console.log(item.encryptedValue, item.value);
-   * }
    * ```
    */
-  delegatedBatchDecryptValues({
-    encryptedInputs,
+  decryptBalanceAs({
     delegatorAddress,
-    accountAddress,
-    maxConcurrency,
-    waitForPropagation
+    accountAddress
   }: {
-    encryptedInputs: EncryptedInput[];
     delegatorAddress: Address;
     accountAddress?: Address;
-    maxConcurrency?: number;
-  } & DelegatedDecryptOptions): Promise<BatchDecryptResult>;
-}
-//#endregion
-//#region src/namespaces/delegations.d.ts
-/**
- * Public namespace for on-chain decryption-delegation management.
- *
- * Exposed as `sdk.delegations`. Owns the SDK-level guards (signer requirement, chain
- * alignment, delegator address resolution from the wallet account) and delegates the
- * actual work to the internal {@link DelegationService}.
- *
- * Delegation operations write to the host chain ACL; after a delegation is mined,
- * the gateway syncs the ACL state via cross-chain event propagation — usually
- * within ~10 blocks (a few seconds). Delegated decryption rides out that window
- * with a bounded internal retry, so callers can decrypt right after granting.
- */
-declare class Delegations {
-  #private;
-  /** @internal */
-  constructor(opts: {
-    signer: GenericSigner | undefined;
-    provider: GenericProvider;
-    delegationService: DelegationService;
-  });
+  }): Promise<bigint>;
   /**
-   * Delegate decryption rights for a confidential contract to another address.
-   * Calls `ACL.delegateForUserDecryption()` on-chain.
+   * Decrypt confidential balances for multiple tokens in parallel, returning
+   * successes and per-token errors separately. Pre-authorizes all token
+   * addresses in a single wallet signature, then delegates each decrypt to
+   * `sdk.decryption.decryptValues`.
    *
-   * The delegation is recorded on L1 immediately, but the gateway must sync the
-   * ACL state via cross-chain event propagation — usually within ~10 blocks (a
-   * few seconds). You do not need to wait: delegated decryption rides out that
-   * window with a bounded internal retry, so you can decrypt right after this
-   * resolves.
+   * Tokens that fail to decrypt land in `errors` rather than aborting the
+   * whole batch — caller decides how to surface them.
    *
-   * @param contractAddress - The confidential contract address to delegate on.
-   * @param delegateAddress - Address to delegate decryption rights to.
-   * @param expirationDate - Optional expiration date (defaults to permanent delegation via `uint64.max`).
-   * @returns The transaction hash and mined receipt.
-   * @throws if no signer is configured. {@link SignerNotConfiguredError}
-   * @throws if signer and provider are on different chains. {@link ChainMismatchError}
-   * @throws if `expirationDate` is less than 1 hour in the future. {@link DelegationExpirationTooSoonError}
-   * @throws if the delegate equals the connected wallet. {@link DelegationSelfNotAllowedError}
-   * @throws if the delegate equals the contract address. {@link DelegationDelegateEqualsContractError}
-   * @throws if the new expiry equals the current one. {@link DelegationExpiryUnchangedError}
-   * @throws if the delegation transaction reverts. {@link TransactionRevertedError}
+   * @param tokens - Array of {@link Token} instances bound to the same SDK.
+   * @param owner - Balance owner address.
+   * @returns `{ results, errors }` partitioning the per-token outcomes.
+   *
+   * @example
+   * ```ts
+   * const { results, errors } = await Token.batchBalancesOf(tokens, owner);
+   * ```
    */
-  delegateDecryption({
-    contractAddress,
-    delegateAddress,
-    expirationDate
-  }: {
-    contractAddress: Address;
-    delegateAddress: Address;
-    expirationDate?: Date;
-  }): Promise<TransactionResult>;
+  static batchBalancesOf(tokens: Token[], owner: Address): Promise<BatchBalancesResult>;
   /**
-   * Revoke decryption delegation for a confidential contract.
-   * Calls `ACL.revokeDelegationForUserDecryption()` on-chain.
+   * Batch decrypt confidential balances as a delegate across multiple tokens.
+   * Mirrors {@link batchBalancesOf} but uses delegated credentials.
    *
-   * @param contractAddress - The confidential contract address to revoke delegation on.
-   * @param delegateAddress - Address to revoke delegation from.
-   * @returns The transaction hash and mined receipt.
-   * @throws if no signer is configured. {@link SignerNotConfiguredError}
-   * @throws if signer and provider are on different chains. {@link ChainMismatchError}
-   * @throws if no delegation exists for this (delegator, delegate, contract) tuple. {@link DelegationNotFoundError}
-   * @throws if the revocation transaction reverts. {@link TransactionRevertedError}
+   * **Error handling:** If a per-token decryption fails and no `onError` callback
+   * is provided, errors are collected and thrown as an aggregated
+   * `DecryptionFailedError`. When the relayer returns no value for an encrypted value,
+   * a `DecryptionFailedError` is thrown for that token (never silently returns `0n`).
+   * Pass `onError: () => 0n` to opt into the silent zero behavior.
+   *
+   * @param tokens - Array of Token instances to decrypt balances for.
+   * @param options - Delegated decryption configuration.
+   * @returns A Map from token address to decrypted balance.
+   * @throws if no active delegation exists. {@link DelegationNotFoundError}
+   * @throws if the delegation has expired. {@link DelegationExpiredError}
+   * @throws if any decryption fails and no `onError` is provided. {@link DecryptionFailedError}
+   *
+   * @example
+   * ```ts
+   * const balances = await Token.batchDecryptBalancesAs(tokens, {
+   *   delegatorAddress: "0xDelegator",
+   *   onError: (err, addr) => { console.error(addr, err); return 0n; },
+   * });
+   * ```
    */
-  revokeDelegation({
-    contractAddress,
-    delegateAddress
-  }: {
-    contractAddress: Address;
-    delegateAddress: Address;
-  }): Promise<TransactionResult>;
+  static batchDecryptBalancesAs(tokens: Token[], options: BatchDecryptAsOptions): Promise<Map<Address, bigint>>;
+  private static readBalanceHandlesBatch;
   /**
-   * Check whether a delegation is active for the given contract address.
+   * Confidential transfer. Encrypts the amount via FHE, then calls the contract.
    *
-   * Signer-independent: works without a configured signer.
+   * By default, the SDK validates the confidential balance before submitting.
+   * If a cached plaintext balance exists it is used; otherwise, if credentials
+   * are cached, it decrypts on the fly. Set `skipBalanceCheck: true` to bypass
+   * this validation (e.g. for smart wallets).
    *
-   * @param contractAddress - The confidential contract address.
-   * @param delegatorAddress - The address that granted the delegation.
-   * @param delegateAddress - The address that received delegation rights.
-   * @returns `true` if the delegation exists and has not expired.
+   * @param to - Recipient address.
+   * @param amount - Plaintext amount to transfer (encrypted automatically via FHE).
+   * @param options - Optional: `skipBalanceCheck` (default `false`).
+   * @returns The transaction hash and mined receipt.
+   * @throws if signer and provider are on different chains. {@link ChainMismatchError}
+   * @throws if the balance is less than `amount`. {@link InsufficientConfidentialBalanceError}
+   * @throws if balance validation requires decryption that is not possible. {@link BalanceCheckUnavailableError}
+   * @throws if FHE encryption fails. {@link EncryptionFailedError}
+   * @throws if the on-chain transfer reverts. {@link TransactionRevertedError}
+   *
+   * @example
+   * ```ts
+   * const txHash = await token.confidentialTransfer("0xRecipient", 1000n);
+   * ```
    */
-  isActive(params: {
-    contractAddress: Address;
-    delegatorAddress: Address;
-    delegateAddress: Address;
-  }): Promise<boolean>;
+  confidentialTransfer(to: Address, amount: bigint, options?: TransferOptions): Promise<TransactionResult>;
   /**
-   * Get the expiration timestamp of a delegation for the given contract.
+   * Operator encrypted transfer on behalf of another address.
+   * The caller must be an approved operator for `from`.
    *
-   * Signer-independent: works without a configured signer.
+   * @param from - The address to transfer from (caller must be an approved operator).
+   * @param to - Recipient address.
+   * @param amount - Plaintext amount to transfer (encrypted automatically via FHE).
+   * @returns The transaction hash and mined receipt.
    *
-   * @param contractAddress - The confidential contract address.
-   * @param delegatorAddress - The address that granted the delegation.
-   * @param delegateAddress - The address that received delegation rights.
-   * @returns Unix timestamp as bigint. `0n` = no delegation. `2^64 - 1` = permanent.
+   * @example
+   * ```ts
+   * const txHash = await token.confidentialTransferFrom("0xFrom", "0xTo", 500n);
+   * ```
    */
-  getExpiry(params: {
-    contractAddress: Address;
-    delegatorAddress: Address;
-    delegateAddress: Address;
-  }): Promise<bigint>;
-}
-//#endregion
-//#region src/namespaces/permits.d.ts
-/**
- * Public namespace for permit and transport-key-pair management.
- *
- * Exposed as `sdk.permits`. Owns the SDK-level guards (chain alignment, empty-array
- * short-circuit, decrypt-cache invalidation) and delegates the actual work to the
- * internal {@link CredentialService}.
- *
- * The namespace is named `permits` because the user-facing concept is the signed-permit
- * store. The transport key pair is invisible plumbing — there is no `getTransportKeyPair()`
- * surfaced; the key pair exists to sign permits and is created automatically when needed.
- * {@link clear} wipes both the permit store and the transport key pair (permits
- * cascade-delete with the key pair).
- */
-declare class Permits {
-  #private;
-  /** @internal */
-  constructor(opts: {
-    signer: GenericSigner | undefined;
-    provider: GenericProvider;
-    cachingService: CachingService;
-    credentialService: CredentialService | undefined;
-    logger: GenericLogger;
-  });
+  confidentialTransferFrom(from: Address, to: Address, amount: bigint, callbacks?: TransferCallbacks): Promise<TransactionResult>;
   /**
-   * Sign and store an EIP-712 permit authorising direct decryption for the
-   * given contract addresses.
+   * ERC-7984 `confidentialTransferAndCall`: encrypted transfer that also invokes
+   * the recipient's receiver hook (`onConfidentialTransferReceived`) in a single
+   * transaction. The caller crafts the opaque `data` payload — the SDK does not
+   * encode, validate, or interpret it.
    *
-   * Idempotent: if a permit covering the requested set already exists, no
-   * wallet prompt occurs. Otherwise the SDK chunks the uncovered subset into
-   * groups of ≤10 contracts and prompts once per chunk; partial mid-flight
-   * rejection is preserved (already-signed chunks are persisted before the
-   * next prompt).
+   * Balance validation follows the same rules as {@link Token.confidentialTransfer}.
    *
-   * @param contracts - Contract addresses to authorize.
-   */
-  grantPermit(contracts: Address[]): Promise<void>;
-  /**
-   * Sign and store an EIP-712 delegation permit authorising decryption on
-   * behalf of `delegator`. Same idempotence/chunking semantics as {@link grantPermit}.
+   * @param to - Recipient address. Must implement the ERC-7984 receiver hook.
+   * @param amount - Plaintext amount to transfer (encrypted automatically via FHE).
+   * @param data - Opaque bytes forwarded to the recipient's receiver hook.
+   * @param options - Optional: `skipBalanceCheck` (default `false`).
+   * @returns The transaction hash and mined receipt.
    *
-   * @param delegator - The address that delegated decryption rights to the connected signer.
-   * @param contracts - Contract addresses to authorize.
+   * @throws if signer and provider are on different chains. {@link ChainMismatchError}
+   * @throws if the balance is less than `amount`. {@link InsufficientConfidentialBalanceError}
+   * @throws if balance validation requires decryption that is not possible. {@link BalanceCheckUnavailableError}
+   * @throws if FHE encryption fails. {@link EncryptionFailedError}
+   * @throws if the on-chain transfer reverts. {@link TransactionRevertedError}
+   *
+   * @example
+   * ```ts
+   * const txHash = await token.confidentialTransferAndCall(
+   *   "0xRecipient",
+   *   1000n,
+   *   "0xabcd", // caller-encoded payload forwarded to the receiver hook
+   * );
+   * ```
    */
-  grantDelegationPermit(delegator: Address, contracts: Address[]): Promise<void>;
+  confidentialTransferAndCall(to: Address, amount: bigint, data: Hex, options?: TransferOptions): Promise<TransactionResult>;
   /**
-   * Pure store lookup: is there a permit covering `contracts`?
-   * No wallet prompt, no transport key pair generation. Returns `false` when no signer
-   * is configured.
+   * ERC-7984 `confidentialTransferFromAndCall`: operator-initiated encrypted
+   * transfer that also invokes the recipient's receiver hook in a single
+   * transaction. The caller must be an approved operator for `from` and crafts
+   * the opaque `data` payload — the SDK does not encode or interpret it.
+   *
+   * @param from - The address to transfer from (caller must be an approved operator).
+   * @param to - Recipient address. Must implement the ERC-7984 receiver hook.
+   * @param amount - Plaintext amount to transfer (encrypted automatically via FHE).
+   * @param data - Opaque bytes forwarded to the recipient's receiver hook.
+   * @param callbacks - Optional progress callbacks.
+   * @returns The transaction hash and mined receipt.
+   *
+   * @example
+   * ```ts
+   * const txHash = await token.confidentialTransferFromAndCall(
+   *   "0xFrom",
+   *   "0xRecipient",
+   *   500n,
+   *   "0xabcd",
+   * );
+   * ```
    */
-  hasPermit(contracts: Address[]): Promise<boolean>;
+  confidentialTransferFromAndCall(from: Address, to: Address, amount: bigint, data: Hex, callbacks?: TransferCallbacks): Promise<TransactionResult>;
   /**
-   * Pure store lookup for a delegation permit. See {@link hasPermit}.
+   * Set operator approval for the confidential token.
+   * Defaults to 1 hour from now if `until` is not specified.
    *
-   * @param delegator - The address that delegated decryption rights to the connected signer.
-   * @param contracts - Contract addresses to check.
-   * @returns `true` if cached delegation permits cover all requested contracts.
+   * @param operator - The address to set as an operator.
+   * @param until - Optional Unix timestamp for approval expiry. Defaults to now + 1 hour.
+   * @returns The transaction hash and mined receipt.
+   *
+   * @example
+   * ```ts
+   * const txHash = await token.setOperator("0xOperator");
+   * ```
    */
-  hasDelegationPermit(delegator: Address, contracts: Address[]): Promise<boolean>;
+  setOperator(operator: Address, until?: number): Promise<TransactionResult>;
   /**
-   * Best-effort transport-key-pair prefetch for the connected signer.
+   * Check if a spender is an approved operator for a given holder.
    *
-   * Optional latency optimization: decrypt and permit flows remain correct
-   * without it because they lazily create the transport key pair when needed.
+   * @param holder - The token holder address.
+   * @param spender - The address to check operator approval for.
+   * @returns `true` if the spender is an approved operator for the holder.
    *
-   * Silent no-op when no signer is configured or no wallet account is
-   * available. The transport key pair is generated through the relayer dispatcher's
-   * currently active chain — see {@link LifecycleService}, which calls
-   * `switchChain` before fanning the wallet-account change out to listeners,
-   * so any downstream caller (including React adapters) observes the
-   * dispatcher on the wallet chain by the time it invokes warmup.
+   * @example
+   * ```ts
+   * if (await token.isOperator("0xHolder", "0xSpender")) {
+   *   // spender can call transferFrom on behalf of holder
+   * }
+   * ```
    */
-  warmTransportKeyPair(): Promise<void>;
+  isOperator(holder: Address, spender: Address): Promise<boolean>;
   /**
-   * Wipe FHE permits for the current signer.
+   * Read the on-chain encrypted balance for a given owner.
    *
-   * - With no argument: every permit referencing this signer is removed across
-   *   all chains and delegators. The transport key pair survives — use {@link clear} to
-   *   also wipe the transport key pair.
-   * - With a contract list: every signed permit in the direct-decrypt scope
-   *   (current chain) whose immutable payload touches any listed address is
-   *   removed. Delegation permits are not touched in this mode.
+   * @internal
+   */
+  protected readConfidentialBalanceOf(owner: Address): Promise<EncryptedValue>;
+  /**
+   * Pre-flight check: decrypt the confidential balance and compare against the
+   * requested amount. If credentials are cached the decrypt happens silently;
+   * if not, throws {@link BalanceCheckUnavailableError} instead of triggering
+   * a surprise EIP-712 popup.
    *
-   * @throws if no signer is configured. {@link SignerNotConfiguredError}
+   * @internal
    */
-  revokePermits(contracts?: Address[]): Promise<void>;
+  protected assertConfidentialBalance(amount: bigint): Promise<void>;
   /**
-   * Wipe the transport key pair for the current signer and cascade-delete every permit
-   * (across chains and delegators) referencing it.
+   * Emit a token-scoped event through the owning {@link ZamaSDK} so that
+   * subscribers see a unified stream.
    *
-   * @throws if no signer is configured. {@link SignerNotConfiguredError}
+   * @internal
    */
-  clear(): Promise<void>;
-}
-//#endregion
-//#region src/token/token.d.ts
-/** Options for {@link Token.batchDecryptBalancesAs}. */
-interface BatchDecryptAsOptions {
-  /** The address of the account that delegated decryption rights. */
-  delegatorAddress: Address;
-  /** Pre-fetched encrypted values. When omitted, they are fetched from the chain. */
-  encryptedValues?: EncryptedValue[];
+  protected emit(input: ZamaSDKEventInput): void;
   /**
-   * The account whose on-chain balance to read. Defaults to the delegator
-   * address, which is the common case (the delegator grants permission to
-   * decrypt their own balance). Only set this when the account differs
-   * from the delegator.
+   * Submit a token-scoped write transaction through the shared SDK transaction
+   * pipeline. Callers keep pre-flight and operation-specific work local.
    *
-   * Matches the `account` parameter of `confidentialBalanceOf(account)` on-chain.
+   * @internal
    */
-  accountAddress?: Address;
-  /** Maximum number of concurrent decrypt calls. Default: 10. */
-  maxConcurrency?: number;
-  /** Called when decryption fails for a single token. Return a fallback bigint. */
-  onError?: (error: Error, address: Address) => bigint;
-}
-/** Result of {@link Token.batchBalancesOf}. */
-interface BatchBalancesResult {
-  /** Successfully decrypted balances, keyed by token address. */
-  results: Map<Address, bigint>;
-  /** Per-token errors for tokens that failed to decrypt. */
-  errors: Map<Address, ZamaError>;
+  protected submitTransaction(params: {
+    operation: TransactionOperation;
+    config: WriteContractConfig;
+    onSubmitted?: (txHash: Hex) => void;
+  }): Promise<TransactionResult>;
+  /** Verify all tokens share the same SDK instance and return it. */
+  private static assertSameSdk;
 }
+//#endregion
+//#region src/token/wrapped-token.d.ts
 /**
- * High-level interface for an ERC-7984 confidential token.
- * Hides FHE complexity (encryption, decryption, EIP-712 signing) behind
- * familiar ERC-20-like methods.
+ * Confidential ERC-20 wrapper (ERC-7984 ERC20Wrapper).
  *
- * For ERC-7984 wrappers (shield/unshield), use {@link WrappedToken} instead —
- * it extends `Token` with wrapper-specific operations.
+ * Extends {@link Token} with wrapper-specific operations:
+ * - `shield` / `unshield` — convert between the underlying ERC-20 and confidential balance
+ * - `unwrap` / `unwrapAll` / `finalizeUnwrap` — low-level two-phase primitives
+ * - `underlying` / `allowance` — wrapper reads
  *
- * Decryption, credentials, caching, and event emission are handled by the
- * owning {@link ZamaSDK} — this class only exposes token-scoped helpers
- * that delegate to `sdk.decryption.decryptValues` and `sdk.permits.grantPermit`.
+ * `WrappedToken.address` is the wrapper contract address itself — the wrapper
+ * IS the confidential token.
  */
-declare class Token {
+declare class WrappedToken extends Token {
   #private;
-  readonly sdk: ZamaSDK;
-  readonly address: Address;
-  constructor(sdk: ZamaSDK, address: Address);
-  /** Read the token name from the contract. */
-  name(): Promise<string>;
-  /** Read the token symbol from the contract. */
-  symbol(): Promise<string>;
-  /** Read the token decimals from the contract. */
-  decimals(): Promise<number>;
   /**
-   * ERC-165 check for {@link ERC7984_INTERFACE_ID} support.
+   * Read the underlying ERC-20 token address from the wrapper contract.
    *
-   * @returns `true` if the contract implements the ERC-7984 confidential token interface.
+   * @returns The underlying ERC-20 token address.
    */
-  isConfidential(): Promise<boolean>;
+  underlying(): Promise<Address>;
   /**
-   * ERC-165 check for IERC7984ERC20Wrapper support.
-   *
-   * @returns `true` if the contract implements the ERC-7984 wrapper interface
-   *   ({@link ERC7984_WRAPPER_INTERFACE_ID}, `0x1f1c62b2`).
+   * Check whether the underlying ERC-20 supports ERC-1363 (payable token).
+   * Result is cached per WrappedToken instance (negative results included):
+   * once we know an underlying does not support ERC-1363, subsequent shields
+   * go straight to the `approve` + `wrap` path without re-probing.
    */
-  isWrapper(): Promise<boolean>;
+  isPayable(): Promise<boolean>;
   /**
-   * Decrypt and return the plaintext balance for the given owner.
-   * Acquires FHE credentials via a wallet signature if none are cached.
-   *
-   * @param owner - Balance owner address.
-   * @returns The decrypted plaintext balance as a bigint.
-   * @throws if FHE decryption fails. {@link DecryptionFailedError}
+   * Read the ERC-20 allowance granted by `owner` to this wrapper for the
+   * underlying token.
    *
-   * @example
-   * ```ts
-   * const balance = await token.balanceOf("0xOwner");
-   * ```
+   * @param owner - The owner address whose allowance to read.
+   * @returns The current allowance as a bigint.
    */
-  balanceOf(owner: Address): Promise<bigint>;
+  allowance(owner: Address): Promise<bigint>;
   /**
-   * Return the raw encrypted balance without decrypting.
+   * Shield public ERC-20 tokens into confidential tokens.
    *
-   * @param owner - Balance owner address.
-   * @returns The encrypted balance as a hex string.
+   * The execution path is decided automatically by ERC-165 introspection on
+   * the underlying ERC-20:
+   * - **`transferAndCall`** (single tx): when the underlying supports
+   *   ERC-1363, no approval is required — the wrapper's `onTransferReceived`
+   *   callback mints confidential tokens directly. `approvalStrategy` is
+   *   **ignored** on this path. See {@link ShieldPath}.
+   * - **`approveAndWrap`** (two-tx fallback): otherwise, an `approve` is
+   *   followed by a `wrap`. Approval is controlled by `approvalStrategy`
+   *   (`"exact"` by default, `"max"` for unlimited, `"skip"` to opt out).
+   *
+   * The ERC-20 balance is validated before submitting (public read, no
+   * signing required) so the call works for all wallet types, including
+   * smart wallets.
+   *
+   * @param amount - The plaintext amount to shield.
+   * @param options - Optional: `approvalStrategy`, `to`, callbacks.
+   * @returns The transaction hash and mined receipt.
+   * @throws if signer and provider are on different chains. {@link ChainMismatchError}
+   * @throws if the ERC-20 balance is less than `amount`. {@link InsufficientERC20BalanceError}
+   * @throws if the ERC-20 approval or shield transaction reverts. {@link TransactionRevertedError}
    *
    * @example
    * ```ts
-   * const encryptedValue = await token.confidentialBalanceOf("0xOwner");
+   * const txHash = await wrappedToken.shield(1000n);
    * ```
    */
-  confidentialBalanceOf(owner: Address): Promise<EncryptedValue>;
+  shield(amount: bigint, options?: ShieldOptions): Promise<TransactionResult>;
   /**
-   * Decrypt the balance of a delegator using delegated decryption credentials.
-   * The connected signer acts as the delegatee who has been granted permission
-   * by the delegator to decrypt their balance.
-   *
-   * Clear values are cached in storage keyed by `(account, token, encryptedValue)`.
-   * Because every on-chain balance change produces a new encrypted value,
-   * stale cache entries are never served. Cache write failures are silently
-   * ignored — they do not affect the returned value.
+   * Approve this wrapper contract to spend the underlying ERC-20.
+   * Defaults to max uint256. Resets to zero first if there's an existing
+   * non-zero allowance (required by tokens like USDT).
    *
-   * @param delegatorAddress - The address of the account that delegated decryption rights.
-   * @param accountAddress - The account whose on-chain balance to read. Defaults
-   *   to the delegator address.
-   * @returns The decrypted plaintext balance as a bigint.
-   * @throws if no active delegation exists. {@link DelegationNotFoundError}
-   * @throws if the delegation has expired. {@link DelegationExpiredError}
-   * @throws if delegated decryption fails. {@link DecryptionFailedError}
+   * @param amount - Optional approval amount. Defaults to max uint256.
+   * @returns The transaction hash and mined receipt.
    *
    * @example
    * ```ts
-   * const balance = await token.decryptBalanceAs({
-   *   delegatorAddress: "0xDelegator",
-   * });
+   * await wrappedToken.approveUnderlying(); // max approval
+   * await wrappedToken.approveUnderlying(1000n); // exact amount
    * ```
    */
-  decryptBalanceAs({
-    delegatorAddress,
-    accountAddress
-  }: {
-    delegatorAddress: Address;
-    accountAddress?: Address;
-  }): Promise<bigint>;
+  approveUnderlying(amount?: bigint): Promise<TransactionResult>;
   /**
-   * Decrypt confidential balances for multiple tokens in parallel, returning
-   * successes and per-token errors separately. Pre-authorizes all token
-   * addresses in a single wallet signature, then delegates each decrypt to
-   * `sdk.decryption.decryptValues`.
+   * Unshield a specific amount and finalize in one call.
+   * Orchestrates: unshield → wait for receipt → parse event → finalize.
    *
-   * Tokens that fail to decrypt land in `errors` rather than aborting the
-   * whole batch — caller decides how to surface them.
+   * By default, the SDK validates the confidential balance before submitting.
+   * Set `skipBalanceCheck: true` to bypass this validation (e.g. for smart wallets).
    *
-   * @param tokens - Array of {@link Token} instances bound to the same SDK.
-   * @param owner - Balance owner address.
-   * @returns `{ results, errors }` partitioning the per-token outcomes.
+   * @param amount - The plaintext amount to unshield.
+   * @param options - Optional: `skipBalanceCheck` (default `false`), callbacks.
+   * @returns The finalize transaction hash and mined receipt.
    *
    * @example
    * ```ts
-   * const { results, errors } = await Token.batchBalancesOf(tokens, owner);
+   * const txHash = await wrappedToken.unshield(500n);
    * ```
    */
-  static batchBalancesOf(tokens: Token[], owner: Address): Promise<BatchBalancesResult>;
+  unshield(amount: bigint, options?: UnshieldOptions): Promise<TransactionResult>;
   /**
-   * Batch decrypt confidential balances as a delegate across multiple tokens.
-   * Mirrors {@link batchBalancesOf} but uses delegated credentials.
-   *
-   * **Error handling:** If a per-token decryption fails and no `onError` callback
-   * is provided, errors are collected and thrown as an aggregated
-   * `DecryptionFailedError`. When the relayer returns no value for an encrypted value,
-   * a `DecryptionFailedError` is thrown for that token (never silently returns `0n`).
-   * Pass `onError: () => 0n` to opt into the silent zero behavior.
+   * Unshield the entire balance and finalize in one call.
+   * Orchestrates: unshieldAll → wait for receipt → parse event → finalize.
    *
-   * @param tokens - Array of Token instances to decrypt balances for.
-   * @param options - Delegated decryption configuration.
-   * @returns A Map from token address to decrypted balance.
-   * @throws if no active delegation exists. {@link DelegationNotFoundError}
-   * @throws if the delegation has expired. {@link DelegationExpiredError}
-   * @throws if any decryption fails and no `onError` is provided. {@link DecryptionFailedError}
+   * @param callbacks - Optional progress callbacks for each phase.
+   * @returns The finalize transaction hash and mined receipt.
+   * @throws if the balance is zero. {@link DecryptionFailedError}
    *
    * @example
    * ```ts
-   * const balances = await Token.batchDecryptBalancesAs(tokens, {
-   *   delegatorAddress: "0xDelegator",
-   *   onError: (err, addr) => { console.error(addr, err); return 0n; },
-   * });
+   * const txHash = await wrappedToken.unshieldAll();
    * ```
    */
-  static batchDecryptBalancesAs(tokens: Token[], options: BatchDecryptAsOptions): Promise<Map<Address, bigint>>;
-  private static readBalanceHandlesBatch;
+  unshieldAll(callbacks?: UnshieldCallbacks): Promise<TransactionResult>;
   /**
-   * Confidential transfer. Encrypts the amount via FHE, then calls the contract.
-   *
-   * By default, the SDK validates the confidential balance before submitting.
-   * If a cached plaintext balance exists it is used; otherwise, if credentials
-   * are cached, it decrypts on the fly. Set `skipBalanceCheck: true` to bypass
-   * this validation (e.g. for smart wallets).
+   * Resume an in-progress unshield from an existing unwrap tx hash.
+   * Useful when the user already submitted the unwrap but the finalize step
+   * was interrupted (e.g. page reload, network error).
    *
-   * @param to - Recipient address.
-   * @param amount - Plaintext amount to transfer (encrypted automatically via FHE).
-   * @param options - Optional: `skipBalanceCheck` (default `false`).
-   * @returns The transaction hash and mined receipt.
-   * @throws if signer and provider are on different chains. {@link ChainMismatchError}
-   * @throws if the balance is less than `amount`. {@link InsufficientConfidentialBalanceError}
-   * @throws if balance validation requires decryption that is not possible. {@link BalanceCheckUnavailableError}
-   * @throws if FHE encryption fails. {@link EncryptionFailedError}
-   * @throws if the on-chain transfer reverts. {@link TransactionRevertedError}
+   * @param unwrapTxHash - The transaction hash of the previously submitted unwrap.
+   * @param callbacks - Optional progress callbacks.
+   * @returns The finalize transaction hash and mined receipt.
    *
    * @example
    * ```ts
-   * const txHash = await token.confidentialTransfer("0xRecipient", 1000n);
+   * const txHash = await wrappedToken.resumeUnshield(previousUnwrapTxHash);
    * ```
    */
-  confidentialTransfer(to: Address, amount: bigint, options?: TransferOptions): Promise<TransactionResult>;
+  resumeUnshield(unwrapTxHash: Hex, callbacks?: UnshieldCallbacks): Promise<TransactionResult>;
   /**
-   * Operator encrypted transfer on behalf of another address.
-   * The caller must be an approved operator for `from`.
+   * Return the unwrap tx hash of an unshield that was interrupted between its
+   * two phases, or `null` if none is pending for this wrapper.
    *
-   * @param from - The address to transfer from (caller must be an approved operator).
-   * @param to - Recipient address.
-   * @param amount - Plaintext amount to transfer (encrypted automatically via FHE).
-   * @returns The transaction hash and mined receipt.
+   * The SDK persists this automatically when {@link unshield}/{@link unshieldAll}
+   * submit phase 1, and clears it once phase 2 finalizes. Use the returned hash
+   * to surface a "resume" affordance, then pass it to {@link resumeUnshield}.
+   * Resuming is intentionally caller-driven — auto-resuming on load would fire a
+   * wallet transaction unprompted.
+   *
+   * @returns The pending unwrap tx hash, or `null`.
    *
    * @example
    * ```ts
-   * const txHash = await token.confidentialTransferFrom("0xFrom", "0xTo", 500n);
+   * const unwrapTxHash = await wrappedToken.getPendingUnshield();
+   * if (unwrapTxHash) await wrappedToken.resumeUnshield(unwrapTxHash);
    * ```
    */
-  confidentialTransferFrom(from: Address, to: Address, amount: bigint, callbacks?: TransferCallbacks): Promise<TransactionResult>;
+  getPendingUnshield(): Promise<Hex | null>;
   /**
-   * ERC-7984 `confidentialTransferAndCall`: encrypted transfer that also invokes
-   * the recipient's receiver hook (`onConfidentialTransferReceived`) in a single
-   * transaction. The caller crafts the opaque `data` payload — the SDK does not
-   * encode, validate, or interpret it.
-   *
-   * Balance validation follows the same rules as {@link Token.confidentialTransfer}.
+   * Request an unwrap for a specific amount. Encrypts the amount first.
+   * Call {@link finalizeUnwrap} after the request is processed on-chain.
    *
-   * @param to - Recipient address. Must implement the ERC-7984 receiver hook.
-   * @param amount - Plaintext amount to transfer (encrypted automatically via FHE).
-   * @param data - Opaque bytes forwarded to the recipient's receiver hook.
-   * @param options - Optional: `skipBalanceCheck` (default `false`).
+   * @param amount - The plaintext amount to unwrap (encrypted automatically).
    * @returns The transaction hash and mined receipt.
    *
-   * @throws if signer and provider are on different chains. {@link ChainMismatchError}
-   * @throws if the balance is less than `amount`. {@link InsufficientConfidentialBalanceError}
-   * @throws if balance validation requires decryption that is not possible. {@link BalanceCheckUnavailableError}
-   * @throws if FHE encryption fails. {@link EncryptionFailedError}
-   * @throws if the on-chain transfer reverts. {@link TransactionRevertedError}
-   *
    * @example
    * ```ts
-   * const txHash = await token.confidentialTransferAndCall(
-   *   "0xRecipient",
-   *   1000n,
-   *   "0xabcd", // caller-encoded payload forwarded to the receiver hook
-   * );
+   * const txHash = await wrappedToken.unwrap(500n);
    * ```
    */
-  confidentialTransferAndCall(to: Address, amount: bigint, data: Hex, options?: TransferOptions): Promise<TransactionResult>;
+  unwrap(amount: bigint): Promise<TransactionResult>;
   /**
-   * ERC-7984 `confidentialTransferFromAndCall`: operator-initiated encrypted
-   * transfer that also invokes the recipient's receiver hook in a single
-   * transaction. The caller must be an approved operator for `from` and crafts
-   * the opaque `data` payload — the SDK does not encode or interpret it.
+   * Request an unwrap for the entire confidential balance.
+   * Uses the on-chain encrypted balance directly (no encryption needed).
+   * Throws if the balance is zero.
    *
-   * @param from - The address to transfer from (caller must be an approved operator).
-   * @param to - Recipient address. Must implement the ERC-7984 receiver hook.
-   * @param amount - Plaintext amount to transfer (encrypted automatically via FHE).
-   * @param data - Opaque bytes forwarded to the recipient's receiver hook.
-   * @param callbacks - Optional progress callbacks.
    * @returns The transaction hash and mined receipt.
+   * @throws if the balance is zero. {@link DecryptionFailedError}
    *
    * @example
    * ```ts
-   * const txHash = await token.confidentialTransferFromAndCall(
-   *   "0xFrom",
-   *   "0xRecipient",
-   *   500n,
-   *   "0xabcd",
-   * );
+   * const txHash = await wrappedToken.unwrapAll();
    * ```
    */
-  confidentialTransferFromAndCall(from: Address, to: Address, amount: bigint, data: Hex, callbacks?: TransferCallbacks): Promise<TransactionResult>;
+  unwrapAll(): Promise<TransactionResult>;
   /**
-   * Set operator approval for the confidential token.
-   * Defaults to 1 hour from now if `until` is not specified.
+   * Complete an unwrap by providing the public decryption proof.
+   * Call this after an unshield request has been processed on-chain.
    *
-   * @param operator - The address to set as an operator.
-   * @param until - Optional Unix timestamp for approval expiry. Defaults to now + 1 hour.
+   * @param unwrapRequestId - `unwrapRequestId` from the `UnwrapRequested` event.
    * @returns The transaction hash and mined receipt.
    *
    * @example
    * ```ts
-   * const txHash = await token.setOperator("0xOperator");
+   * const event = findUnwrapRequested(receipt.logs);
+   * const txHash = await wrappedToken.finalizeUnwrap(event.unwrapRequestId);
    * ```
    */
-  setOperator(operator: Address, until?: number): Promise<TransactionResult>;
-  /**
-   * Check if a spender is an approved operator for a given holder.
-   *
-   * @param holder - The token holder address.
-   * @param spender - The address to check operator approval for.
-   * @returns `true` if the spender is an approved operator for the holder.
-   *
-   * @example
-   * ```ts
-   * if (await token.isOperator("0xHolder", "0xSpender")) {
-   *   // spender can call transferFrom on behalf of holder
-   * }
-   * ```
-   */
-  isOperator(holder: Address, spender: Address): Promise<boolean>;
-  /**
-   * Read the on-chain encrypted balance for a given owner.
-   *
-   * @internal
-   */
-  protected readConfidentialBalanceOf(owner: Address): Promise<EncryptedValue>;
+  finalizeUnwrap(unwrapRequestId: EncryptedValue): Promise<TransactionResult>;
+}
+//#endregion
+//#region src/query/confidential-balance.d.ts
+interface ConfidentialBalanceQueryConfig {
+  tokenAddress: Address;
+  account?: Address;
+  query?: Record<string, unknown>;
+}
+/** Query options for a single confidential token balance. Auto-gated on `account`. */
+declare function confidentialBalanceQueryOptions(token: Token, config: ConfidentialBalanceQueryConfig, signerContext?: SignerQueryContext): QueryFactoryOptions<bigint, Error, bigint, ReturnType<typeof zamaQueryKeys.confidentialBalance.owner>>;
+//#endregion
+//#region src/query/confidential-balances.d.ts
+interface ConfidentialBalancesQueryConfig {
+  account?: Address;
+  query?: Record<string, unknown>;
+}
+declare function confidentialBalancesQueryOptions(tokens: Token[], config?: ConfidentialBalancesQueryConfig, signerContext?: SignerQueryContext): QueryFactoryOptions<BatchBalancesResult, Error, BatchBalancesResult, ReturnType<typeof zamaQueryKeys.confidentialBalances.tokens>>;
+//#endregion
+//#region src/query/wrappers-registry.d.ts
+interface WrappersRegistryQueryConfig {
+  registryAddress: Address | undefined;
+  query?: Record<string, unknown>;
+}
+declare function tokenPairsQueryOptions(sdk: ZamaSDK, config: WrappersRegistryQueryConfig): QueryFactoryOptions<readonly TokenWrapperPair[], Error, readonly TokenWrapperPair[], ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenPairs>>;
+interface ConfidentialTokenAddressQueryConfig extends WrappersRegistryQueryConfig {
+  tokenAddress?: Address;
+}
+declare function confidentialTokenAddressQueryOptions(sdk: ZamaSDK, config: ConfidentialTokenAddressQueryConfig): QueryFactoryOptions<readonly [boolean, Address], Error, readonly [boolean, Address], ReturnType<typeof zamaQueryKeys.wrappersRegistry.confidentialTokenAddress>>;
+interface TokenAddressQueryConfig extends WrappersRegistryQueryConfig {
+  confidentialTokenAddress?: Address;
+}
+declare function tokenAddressQueryOptions(sdk: ZamaSDK, config: TokenAddressQueryConfig): QueryFactoryOptions<readonly [boolean, Address], Error, readonly [boolean, Address], ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenAddress>>;
+declare function tokenPairsLengthQueryOptions(sdk: ZamaSDK, config: WrappersRegistryQueryConfig): QueryFactoryOptions<bigint, Error, bigint, ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenPairsLength>>;
+interface TokenPairsSliceQueryConfig extends WrappersRegistryQueryConfig {
+  fromIndex?: bigint;
+  toIndex?: bigint;
+}
+declare function tokenPairsSliceQueryOptions(sdk: ZamaSDK, config: TokenPairsSliceQueryConfig): QueryFactoryOptions<readonly TokenWrapperPair[], Error, readonly TokenWrapperPair[], ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenPairsSlice>>;
+interface TokenPairQueryConfig extends WrappersRegistryQueryConfig {
+  index?: bigint;
+}
+declare function tokenPairQueryOptions(sdk: ZamaSDK, config: TokenPairQueryConfig): QueryFactoryOptions<TokenWrapperPair, Error, TokenWrapperPair, ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenPair>>;
+interface IsConfidentialTokenValidQueryConfig extends WrappersRegistryQueryConfig {
+  confidentialTokenAddress?: Address;
+}
+declare function isConfidentialTokenValidQueryOptions(sdk: ZamaSDK, config: IsConfidentialTokenValidQueryConfig): QueryFactoryOptions<boolean, Error, boolean, ReturnType<typeof zamaQueryKeys.wrappersRegistry.isConfidentialTokenValid>>;
+interface ListPairsQueryConfig {
   /**
-   * Pre-flight check: decrypt the confidential balance and compare against the
-   * requested amount. If credentials are cached the decrypt happens silently;
-   * if not, throws {@link BalanceCheckUnavailableError} instead of triggering
-   * a surprise EIP-712 popup.
-   *
-   * @internal
+   * The registry address for this chain — used as a query key discriminator.
+   * The registry instance already knows how to resolve the address for the
+   * current chain; this field just keeps the TanStack Query cache isolated
+   * per registry contract.
    */
-  protected assertConfidentialBalance(amount: bigint): Promise<void>;
+  registryAddress: Address | undefined;
+  page?: number;
+  pageSize?: number;
+  metadata?: boolean;
+  query?: Record<string, unknown>;
+}
+/**
+ * Query options for paginated listing of token wrapper pairs.
+ *
+ * Accepts a {@link WrappersRegistry} instance rather than a raw provider so that the
+ * class-level TTL cache is shared across multiple `queryFn` executions. Pass
+ * `sdk.registry` (the ZamaSDK lazy singleton) to ensure a single shared cache.
+ */
+declare function listPairsQueryOptions(registry: WrappersRegistry, config: ListPairsQueryConfig): QueryFactoryOptions<PaginatedResult<TokenWrapperPair | TokenWrapperPairWithMetadata>, Error, PaginatedResult<TokenWrapperPair | TokenWrapperPairWithMetadata>, ReturnType<typeof zamaQueryKeys.wrappersRegistry.listPairs>>;
+//#endregion
+//#region src/query/shield.d.ts
+/** Variables for {@link shieldMutationOptions}. */
+interface ShieldParams extends ShieldOptions {
+  amount: bigint;
+}
+declare function shieldMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.shield", Address], ShieldParams, TransactionResult>;
+//#endregion
+//#region src/query/transfer.d.ts
+/** Variables for {@link confidentialTransferMutationOptions}. */
+interface ConfidentialTransferParams extends TransferOptions {
+  to: Address;
+  amount: bigint;
+}
+declare function confidentialTransferMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.confidentialTransfer", Address], ConfidentialTransferParams, TransactionResult>;
+//#endregion
+//#region src/query/transfer-and-call.d.ts
+/** Variables for {@link confidentialTransferAndCallMutationOptions}. */
+interface ConfidentialTransferAndCallParams extends TransferOptions {
+  to: Address;
+  amount: bigint;
+  /** Opaque bytes forwarded to the recipient's ERC-7984 receiver hook. */
+  data: Hex;
+}
+declare function confidentialTransferAndCallMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.confidentialTransferAndCall", Address], ConfidentialTransferAndCallParams, TransactionResult>;
+//#endregion
+//#region src/query/transfer-from.d.ts
+/** Variables for {@link confidentialTransferFromMutationOptions}. */
+interface ConfidentialTransferFromParams {
+  from: Address;
+  to: Address;
+  amount: bigint;
+  /** Optional progress callbacks for the multi-step transfer flow. */
+  callbacks?: TransferCallbacks;
+}
+declare function confidentialTransferFromMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.confidentialTransferFrom", Address], ConfidentialTransferFromParams, TransactionResult>;
+//#endregion
+//#region src/query/transfer-from-and-call.d.ts
+/** Variables for {@link confidentialTransferFromAndCallMutationOptions}. */
+interface ConfidentialTransferFromAndCallParams {
+  from: Address;
+  to: Address;
+  amount: bigint;
+  /** Opaque bytes forwarded to the recipient's ERC-7984 receiver hook. */
+  data: Hex;
+  /** Optional progress callbacks for the multi-step transfer flow. */
+  callbacks?: TransferCallbacks;
+}
+declare function confidentialTransferFromAndCallMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.confidentialTransferFromAndCall", Address], ConfidentialTransferFromAndCallParams, TransactionResult>;
+//#endregion
+//#region src/query/set-operator.d.ts
+/** Variables for {@link confidentialSetOperatorMutationOptions}. */
+interface ConfidentialSetOperatorParams {
+  operator: Address;
+  until?: number;
+}
+declare function confidentialSetOperatorMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.confidentialSetOperator", Address], ConfidentialSetOperatorParams, TransactionResult>;
+//#endregion
+//#region src/query/approve-underlying.d.ts
+/** Variables for {@link approveUnderlyingMutationOptions}. */
+interface ApproveUnderlyingParams {
+  amount?: bigint;
+}
+declare function approveUnderlyingMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.approveUnderlying", Address], ApproveUnderlyingParams, TransactionResult>;
+//#endregion
+//#region src/query/unshield.d.ts
+/** Variables for {@link unshieldMutationOptions}. */
+interface UnshieldParams extends UnshieldOptions {
+  amount: bigint;
+}
+declare function unshieldMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.unshield", Address], UnshieldParams, TransactionResult>;
+//#endregion
+//#region src/query/unshield-all.d.ts
+/** Variables for {@link unshieldAllMutationOptions}. */
+interface UnshieldAllParams extends UnshieldCallbacks {}
+declare function unshieldAllMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.unshieldAll", Address], UnshieldAllParams | void, TransactionResult>;
+//#endregion
+//#region src/query/resume-unshield.d.ts
+/** Variables for {@link resumeUnshieldMutationOptions}. */
+interface ResumeUnshieldParams extends UnshieldCallbacks {
+  unwrapTxHash: Hex;
+}
+declare function resumeUnshieldMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.resumeUnshield", Address], ResumeUnshieldParams, TransactionResult>;
+//#endregion
+//#region src/query/unwrap.d.ts
+/** Variables for {@link unwrapMutationOptions}. */
+interface UnwrapParams {
+  amount: bigint;
+}
+declare function unwrapMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.unwrap", Address], UnwrapParams, TransactionResult>;
+//#endregion
+//#region src/query/unwrap-all.d.ts
+declare function unwrapAllMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.unwrapAll", Address], void, TransactionResult>;
+//#endregion
+//#region src/query/finalize-unwrap.d.ts
+/** Variables for {@link finalizeUnwrapMutationOptions}. */
+type FinalizeUnwrapParams = {
+  /** Identifier from an `UnwrapRequested` event. */unwrapRequestId: EncryptedValue;
+};
+declare function finalizeUnwrapMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.finalizeUnwrap", Address], FinalizeUnwrapParams, TransactionResult>;
+//#endregion
+//#region src/query/encrypt.d.ts
+declare function encryptMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.encrypt"], EncryptParams, EncryptResult>;
+//#endregion
+//#region src/query/user-decrypt.d.ts
+interface EncryptedInput {
+  encryptedValue: EncryptedValue;
+  contractAddress: Address;
+}
+/** Decrypted clear values keyed by encrypted handle. */
+type DecryptResult = Readonly<Record<EncryptedValue, ClearValue>>;
+declare function decryptValuesQueryOptions(sdk: ZamaSDK, encryptedInputs: EncryptedInput[], signerContext?: SignerQueryContext): QueryFactoryOptions<DecryptResult, Error, DecryptResult, ReturnType<typeof zamaQueryKeys.decryption.encryptedInputs>>;
+//#endregion
+//#region src/query/delegated-decrypt.d.ts
+interface DelegatedDecryptValuesMutationParams {
+  encryptedInputs: EncryptedInput[];
+  delegatorAddress: Address;
+}
+declare function delegatedDecryptValuesMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.delegatedDecryptValues"], DelegatedDecryptValuesMutationParams, Readonly<Record<EncryptedValue, ClearValue>>>;
+//#endregion
+//#region src/query/public-decrypt.d.ts
+declare function decryptPublicValuesMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.decryptPublicValues"], EncryptedValue[], DecryptPublicValuesResult>;
+//#endregion
+//#region src/query/grant-permit.d.ts
+declare function grantPermitMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.grantPermit"], Address[], void>;
+//#endregion
+//#region src/query/has-permit.d.ts
+interface HasPermitQueryConfig {
+  /** Contract addresses to check credentials against. */
+  contractAddresses: Address[];
   /**
-   * Emit a token-scoped event through the owning {@link ZamaSDK} so that
-   * subscribers see a unified stream.
-   *
-   * @internal
+   * Standard TanStack query options. `hasPermit` intentionally overrides cache
+   * timing because permit state is wallet-local, not server state: every fetch
+   * should read the SDK credential service directly.
    */
-  protected emit(input: ZamaSDKEventInput): void;
-  /**
-   * Submit a token-scoped write transaction through the shared SDK transaction
-   * pipeline. Callers keep pre-flight and operation-specific work local.
-   *
-   * @internal
-   */
-  protected submitTransaction(params: {
-    operation: TransactionOperation;
-    config: WriteContractConfig;
-    onSubmitted?: (txHash: Hex) => void;
-  }): Promise<TransactionResult>;
-  /** Verify all tokens share the same SDK instance and return it. */
-  private static assertSameSdk;
+  query?: Record<string, unknown>;
 }
+declare function hasPermitQueryOptions(sdk: ZamaSDK, config: HasPermitQueryConfig, signerContext?: SignerQueryContext): QueryFactoryOptions<boolean, Error, boolean, ReturnType<typeof zamaQueryKeys.hasPermit.scope>>;
 //#endregion
-//#region src/token/wrapped-token.d.ts
+//#region src/query/revoke-permits.d.ts
+/** TanStack Query mutation factory for {@link Permits.revokePermits}. */
+declare function revokePermitsMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.revokePermits"], Address[] | void, void>;
+//#endregion
+//#region src/query/clear-credentials.d.ts
+/** TanStack Query mutation factory for {@link Permits.clear}. */
+declare function clearCredentialsMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.clearCredentials"], void, void>;
+//#endregion
+//#region src/query/delegate-decryption.d.ts
+/** Variables for {@link delegateDecryptionMutationOptions}. */
+interface DelegateDecryptionParams {
+  delegateAddress: Address;
+  expirationDate?: Date;
+}
+declare function delegateDecryptionMutationOptions(sdk: ZamaSDK, contractAddress: Address): MutationFactoryOptions<readonly ["zama.delegateDecryption", Address], DelegateDecryptionParams, TransactionResult>;
+//#endregion
+//#region src/query/decrypt-balance-as.d.ts
+/** Variables for {@link decryptBalanceAsMutationOptions}. */
+interface DecryptBalanceAsParams {
+  delegatorAddress: Address;
+  accountAddress?: Address;
+}
+declare function decryptBalanceAsMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.decryptBalanceAs", Address], DecryptBalanceAsParams, bigint>;
+//#endregion
+//#region src/query/batch-decrypt-balances-as.d.ts
+/** Variables for {@link batchDecryptBalancesAsMutationOptions}. */
+type BatchDecryptBalancesAsParams = BatchDecryptAsOptions;
+declare function batchDecryptBalancesAsMutationOptions(tokens: Token[]): MutationFactoryOptions<readonly ["zama.batchDecryptBalancesAs", ...Address[]], BatchDecryptBalancesAsParams, Map<Address, bigint>>;
+//#endregion
+//#region src/query/revoke-delegation.d.ts
+/** Variables for {@link revokeDelegationMutationOptions}. */
+interface RevokeDelegationParams {
+  delegateAddress: Address;
+}
+declare function revokeDelegationMutationOptions(sdk: ZamaSDK, contractAddress: Address): MutationFactoryOptions<readonly ["zama.revokeDelegation", Address], RevokeDelegationParams, TransactionResult>;
+//#endregion
+//#region src/query/delegation-status.d.ts
+interface DelegationStatusData {
+  isActive: boolean;
+  expiryTimestamp: bigint;
+}
+interface DelegationStatusQueryConfig {
+  contractAddress: Address | undefined;
+  delegatorAddress?: Address;
+  delegateAddress?: Address;
+  query?: Record<string, unknown>;
+}
+declare function delegationStatusQueryOptions(sdk: ZamaSDK, config: DelegationStatusQueryConfig): QueryFactoryOptions<DelegationStatusData, Error, DelegationStatusData, ReturnType<typeof zamaQueryKeys.delegationStatus.scope>>;
+//#endregion
+//#region src/credentials/credential-service.d.ts
+/** Configuration for {@link CredentialService}. TTLs are pre-validated by the caller. */
+interface CredentialServiceConfig {
+  router: ChainRouter;
+  signer: GenericSigner;
+  /** Transport key pair lifetime in seconds. Pre-validated. */
+  transportKeyPairTTL: number;
+  /** Permit lifetime in days. Pre-validated. */
+  permitTTL: number;
+  /** Backing storage for transport key pairs (and permits if `permitStorage` is omitted). */
+  storage: GenericStorage;
+  /** Optional dedicated storage for permits; defaults to `storage`. */
+  permitStorage?: GenericStorage;
+  /** SDK-wide logger for credential-path diagnostics. */
+  logger: GenericLogger;
+}
 /**
- * Confidential ERC-20 wrapper (ERC-7984 ERC20Wrapper).
- *
- * Extends {@link Token} with wrapper-specific operations:
- * - `shield` / `unshield` — convert between the underlying ERC-20 and confidential balance
- * - `unwrap` / `unwrapAll` / `finalizeUnwrap` — low-level two-phase primitives
- * - `underlying` / `allowance` — wrapper reads
+ * Single facade coordinating the keypair vault and the permission store.
  *
- * `WrappedToken.address` is the wrapper contract address itself — the wrapper
- * IS the confidential token.
+ * `CredentialService` is the only credentials object held by `ZamaSDK`. It accepts identity
+ * transitions via `handleWalletAccountChange`.
  */
-declare class WrappedToken extends Token {
+declare class CredentialService {
   #private;
+  constructor(config: CredentialServiceConfig);
   /**
-   * Read the underlying ERC-20 token address from the wrapper contract.
+   * Resolve a keypair and permissions covering `contracts`, minimizing wallet
+   * prompts by reusing or widening existing permits where possible. Empty
+   * `contracts` warms the keypair without prompting.
    *
-   * @returns The underlying ERC-20 token address.
+   * @returns The resolved keypair and permits covering the requested contracts.
+   * @throws if the user rejects a wallet signature prompt. {@link SigningRejectedError}
+   * @throws if signing fails for any other reason. {@link SigningFailedError}
    */
-  underlying(): Promise<Address>;
+  grantPermit(contracts: readonly Address[], delegator?: Address): Promise<SerializedTransportKeyPairWithPermissions>;
   /**
-   * Check whether the underlying ERC-20 supports ERC-1363 (payable token).
-   * Result is cached per WrappedToken instance (negative results included):
-   * once we know an underlying does not support ERC-1363, subsequent shields
-   * go straight to the `approve` + `wrap` path without re-probing.
-   */
-  isPayable(): Promise<boolean>;
-  /**
-   * Read the ERC-20 allowance granted by `owner` to this wrapper for the
-   * underlying token.
+   * Pure store lookup: are stored permits sufficient to cover `contracts`? No wallet prompt.
    *
-   * @param owner - The owner address whose allowance to read.
-   * @returns The current allowance as a bigint.
+   * @returns `true` if cached permits cover all requested contracts (vacuously
+   *   true for an empty list); `false` if no keypair exists or coverage is
+   *   incomplete.
    */
-  allowance(owner: Address): Promise<bigint>;
+  hasPermit(contracts: readonly Address[], delegator?: Address): Promise<boolean>;
   /**
-   * Shield public ERC-20 tokens into confidential tokens.
-   *
-   * The execution path is decided automatically by ERC-165 introspection on
-   * the underlying ERC-20:
-   * - **`transferAndCall`** (single tx): when the underlying supports
-   *   ERC-1363, no approval is required — the wrapper's `onTransferReceived`
-   *   callback mints confidential tokens directly. `approvalStrategy` is
-   *   **ignored** on this path. See {@link ShieldPath}.
-   * - **`approveAndWrap`** (two-tx fallback): otherwise, an `approve` is
-   *   followed by a `wrap`. Approval is controlled by `approvalStrategy`
-   *   (`"exact"` by default, `"max"` for unlimited, `"skip"` to opt out).
-   *
-   * The ERC-20 balance is validated before submitting (public read, no
-   * signing required) so the call works for all wallet types, including
-   * smart wallets.
+   * Wipe FHE permits for the current signer.
    *
-   * @param amount - The plaintext amount to shield.
-   * @param options - Optional: `approvalStrategy`, `to`, callbacks.
-   * @returns The transaction hash and mined receipt.
-   * @throws if signer and provider are on different chains. {@link ChainMismatchError}
-   * @throws if the ERC-20 balance is less than `amount`. {@link InsufficientERC20BalanceError}
-   * @throws if the ERC-20 approval or shield transaction reverts. {@link TransactionRevertedError}
+   * - With no argument: every permit referencing this signer is removed across
+   *   all chains and delegators. The keypair survives — use
+   *   {@link clearCredentials} to also wipe the keypair.
+   * - With a contract list: every signed permit in the direct-decrypt scope
+   *   (current chain) whose immutable payload touches any listed address is
+   *   removed. Delegated permits are not touched in this mode.
    *
-   * @example
-   * ```ts
-   * const txHash = await wrappedToken.shield(1000n);
-   * ```
+   * @throws if reading the signer address fails. {@link SigningFailedError}
    */
-  shield(amount: bigint, options?: ShieldOptions): Promise<TransactionResult>;
+  revokePermits(contracts?: readonly Address[]): Promise<void>;
   /**
-   * Approve this wrapper contract to spend the underlying ERC-20.
-   * Defaults to max uint256. Resets to zero first if there's an existing
-   * non-zero allowance (required by tokens like USDT).
-   *
-   * @param amount - Optional approval amount. Defaults to max uint256.
-   * @returns The transaction hash and mined receipt.
+   * Wipe the keypair for the current signer and cascade-delete every
+   * permission referencing it across all chains and delegators.
    *
-   * @example
-   * ```ts
-   * await wrappedToken.approveUnderlying(); // max approval
-   * await wrappedToken.approveUnderlying(1000n); // exact amount
-   * ```
+   * @throws if reading the signer address fails. {@link SigningFailedError}
    */
-  approveUnderlying(amount?: bigint): Promise<TransactionResult>;
+  clearCredentials(): Promise<void>;
   /**
-   * Unshield a specific amount and finalize in one call.
-   * Orchestrates: unshield → wait for receipt → parse event → finalize.
-   *
-   * By default, the SDK validates the confidential balance before submitting.
-   * Set `skipBalanceCheck: true` to bypass this validation (e.g. for smart wallets).
+   * Warm the signer transport key pair cache for a known address.
    *
-   * @param amount - The plaintext amount to unshield.
-   * @param options - Optional: `skipBalanceCheck` (default `false`), callbacks.
-   * @returns The finalize transaction hash and mined receipt.
+   * Best-effort prefetch primitive: correctness still comes from `grantPermit`,
+   * which lazily creates the transport key pair when needed. Errors (storage failure,
+   * relayer 4xx, missing Worker in SSR) are **not** swallowed here — the caller
+   * decides whether to log, ignore, or surface them.
+   */
+  warmTransportKeyPair(address: Address): Promise<void>;
+  /**
+   * Apply a wallet account transition.
    *
-   * @example
-   * ```ts
-   * const txHash = await wrappedToken.unshield(500n);
-   * ```
+   * Address change clears persisted credentials for the previous account.
+   * Chain-only changes keep credentials intact because permits are chain-scoped
+   * already and stale decrypt plaintext is cleared by `ZamaSDK`.
    */
-  unshield(amount: bigint, options?: UnshieldOptions): Promise<TransactionResult>;
+  handleWalletAccountChange(prev?: {
+    address: Address;
+  }, next?: {
+    address: Address;
+  }): Promise<void>;
+}
+//#endregion
+//#region src/services/caching-service.d.ts
+/**
+ * Storage-backed cache for decrypted FHE plaintext values.
+ *
+ * Each entry is keyed by `(requester, contractAddress, handle)` so different
+ * signers cannot read each other's cached decryptions.
+ */
+declare class CachingService {
+  #private;
+  constructor(storage: GenericStorage, logger: GenericLogger);
+  get(requester: Address, contractAddress: Address, encryptedValue: EncryptedValue): Promise<ClearValue | null>;
+  set(requester: Address, contractAddress: Address, encryptedValue: EncryptedValue, value: ClearValue): Promise<void>;
+  delete(requester: Address, contractAddress: Address, encryptedValue: EncryptedValue): Promise<void>;
+  clearForRequester(requester: Address): Promise<void>;
+  clearAll(): Promise<void>;
+}
+//#endregion
+//#region src/services/delegation-service.d.ts
+declare class DelegationService {
+  #private;
+  constructor({
+    provider,
+    router,
+    emitEvent,
+    logger
+  }: {
+    provider: GenericProvider;
+    router: ChainRouter;
+    logger: GenericLogger;
+    emitEvent?: (input: ZamaSDKEventInput, tokenAddress?: Address) => void;
+  });
+  delegateDecryption(signer: GenericSigner, {
+    contractAddress,
+    delegateAddress,
+    delegatorAddress,
+    expirationDate
+  }: {
+    contractAddress: Address;
+    delegateAddress: Address;
+    delegatorAddress: Address;
+    expirationDate?: Date;
+  }): Promise<TransactionResult>;
+  revokeDelegation(signer: GenericSigner, {
+    contractAddress,
+    delegateAddress,
+    delegatorAddress
+  }: {
+    contractAddress: Address;
+    delegateAddress: Address;
+    delegatorAddress: Address;
+  }): Promise<TransactionResult>;
+  isDelegated(params: {
+    contractAddress: Address;
+    delegatorAddress: Address;
+    delegateAddress: Address;
+  }): Promise<boolean>;
+  getDelegationExpiry({
+    contractAddress,
+    delegatorAddress,
+    delegateAddress
+  }: {
+    contractAddress: Address;
+    delegatorAddress: Address;
+    delegateAddress: Address;
+  }): Promise<bigint>;
+  findInactiveDelegations(contractAddresses: readonly Address[], delegatorAddress: Address, delegateAddress: Address): Promise<Map<Address, DelegationNotFoundError | DelegationExpiredError>>;
+  assertDelegationActive(contractAddress: Address, delegatorAddress: Address, delegateAddress: Address): Promise<void>;
+}
+//#endregion
+//#region src/services/decryption-service.d.ts
+/** Options shared by the delegated-decrypt entry points. */
+interface DelegatedDecryptOptions {
+  /**
+   * Ride out the gateway propagation window: when a just-granted delegation
+   * has not yet synced, the delegated decrypt is retried (bounded, ~30s) until
+   * it lands instead of throwing {@link DelegationNotPropagatedError}. Defaults
+   * to `true`. Pass `false` to fail fast on the first not-propagated response.
+   */
+  waitForPropagation?: boolean;
+}
+interface BatchDecryptItem {
+  encryptedValue: EncryptedValue;
+  contractAddress: Address;
+  value?: ClearValue;
+  error?: ZamaError;
+}
+interface BatchDecryptResult {
+  items: BatchDecryptItem[];
+}
+declare class DecryptionService {
+  #private;
+  constructor({
+    cache,
+    credentialService,
+    delegationService,
+    router,
+    emitEvent
+  }: {
+    cache: CachingService;
+    credentialService: CredentialService;
+    delegationService: DelegationService;
+    router: ChainRouter;
+    emitEvent: (input: ZamaSDKEventInput) => void;
+  });
+  decryptValues(handles: EncryptedInput[], signerAddress: Address, opts?: Pick<FhevmRelayerOptions, "signal" | "timeout">): Promise<Record<EncryptedValue, ClearValue>>;
+  delegatedDecryptValues(encryptedInputs: EncryptedInput[], delegatorAddress: Address, delegateAddress: Address, accountAddress: Address, opts?: DelegatedDecryptOptions): Promise<Record<EncryptedValue, ClearValue>>;
+  delegatedBatchDecryptHandlesAs({
+    encryptedInputs,
+    delegatorAddress,
+    delegateAddress,
+    accountAddress,
+    maxConcurrency,
+    waitForPropagation
+  }: {
+    encryptedInputs: EncryptedInput[];
+    delegatorAddress: Address;
+    delegateAddress: Address;
+    accountAddress: Address;
+    maxConcurrency?: number;
+    waitForPropagation?: boolean;
+  }): Promise<BatchDecryptResult>;
+}
+//#endregion
+//#region src/namespaces/decryption.d.ts
+/**
+ * Public namespace for FHE decryption — the canonical way to decrypt.
+ *
+ * Exposed as `sdk.decryption`. Prefer these methods over the low-level
+ * `sdk.relayer.decryptValues` / `decryptPublicValues`: they
+ * assemble the credential bundle (transport key pair, EIP-712 permit) for you,
+ * cache results, and wrap relayer errors. Reach for `sdk.relayer.*` only when
+ * you must control credential assembly by hand.
+ *
+ * Owns the SDK-level guards (signer requirement on
+ * `decryptValues` and `delegatedDecryptValues`, empty-array
+ * short-circuit on `decryptPublicValues`, relayer error wrapping) and delegates the
+ * actual work to the internal {@link DecryptionService} or the relayer directly for
+ * `decryptPublicValues`.
+ *
+ * **Mixed signer requirement:** `decryptValues` and
+ * `delegatedDecryptValues` need a configured signer; `decryptPublicValues`
+ * does not. Each method documents its requirement in its JSDoc.
+ */
+declare class Decryption {
+  #private;
+  /** @internal */
+  constructor(opts: {
+    signer: GenericSigner | undefined;
+    provider: GenericProvider;
+    router: ChainRouter;
+    decryptionService: DecryptionService | undefined;
+  });
   /**
-   * Unshield the entire balance and finalize in one call.
-   * Orchestrates: unshieldAll → wait for receipt → parse event → finalize.
-   *
-   * @param callbacks - Optional progress callbacks for each phase.
-   * @returns The finalize transaction hash and mined receipt.
-   * @throws if the balance is zero. {@link DecryptionFailedError}
+   * Decrypt one or more FHE encrypted values. Results are cached — repeated calls
+   * for the same encrypted value skip the relayer round-trip.
    *
-   * @example
-   * ```ts
-   * const txHash = await wrappedToken.unshieldAll();
-   * ```
-   */
-  unshieldAll(callbacks?: UnshieldCallbacks): Promise<TransactionResult>;
-  /**
-   * Resume an in-progress unshield from an existing unwrap tx hash.
-   * Useful when the user already submitted the unwrap but the finalize step
-   * was interrupted (e.g. page reload, network error).
+   * Zero encrypted values are mapped to `0n` without hitting the relayer.
+   * Events (`DecryptStart/End/Error`) are emitted uniformly.
+   * Relayer errors are wrapped into typed SDK errors.
    *
-   * @param unwrapTxHash - The transaction hash of the previously submitted unwrap.
-   * @param callbacks - Optional progress callbacks.
-   * @returns The finalize transaction hash and mined receipt.
+   * @param encryptedInput - Encrypted values to decrypt, each paired with its contract address.
+   * @param options - Per-call `signal` and `timeout` forwarded to the relayer round-trip.
+   * @returns A record mapping each encrypted value to its decrypted clear-text value.
+   * @throws if no signer is configured. {@link SignerNotConfiguredError}
+   * @throws if signer and provider are on different chains. {@link ChainMismatchError}
    *
    * @example
    * ```ts
-   * const txHash = await wrappedToken.resumeUnshield(previousUnwrapTxHash);
+   * const values = await sdk.decryption.decryptValues([
+   *   { encryptedValue: balance, contractAddress: cUSDT },
+   * ]);
+   * console.log(values[balance]); // 1000n
    * ```
    */
-  resumeUnshield(unwrapTxHash: Hex, callbacks?: UnshieldCallbacks): Promise<TransactionResult>;
+  decryptValues(encryptedInput: EncryptedInput[], options?: Pick<FhevmRelayerOptions, "signal" | "timeout">): Promise<Record<EncryptedValue, ClearValue>>;
   /**
-   * Return the unwrap tx hash of an unshield that was interrupted between its
-   * two phases, or `null` if none is pending for this wrapper.
+   * Decrypt one or more FHE encrypted values using delegated credentials.
    *
-   * The SDK persists this automatically when {@link unshield}/{@link unshieldAll}
-   * submit phase 1, and clears it once phase 2 finalizes. Use the returned hash
-   * to surface a "resume" affordance, then pass it to {@link resumeUnshield}.
-   * Resuming is intentionally caller-driven — auto-resuming on load would fire a
-   * wallet transaction unprompted.
+   * Mirrors {@link decryptValues} with delegated credentials — same caching and
+   * zero-value short-circuit. Before reading from cache or calling the relayer,
+   * every non-zero encrypted value's contract must have an active delegation from the
+   * delegator to the connected signer; missing or expired delegations fail fast.
    *
-   * @returns The pending unwrap tx hash, or `null`.
+   * @param encryptedInputs - FHE encrypted values paired with their contract addresses.
+   * @param delegatorAddress - The address that granted delegation rights.
+   * @param accountAddress - Address used as the cache key's "requester"
+   *   dimension. Defaults to `delegatorAddress`. Pass the actual account address
+   *   when decrypting on behalf of someone whose balance is stored under a
+   *   different address (e.g. `decryptBalanceAs` with an explicit `accountAddress`).
+   * @param options - Delegated-decrypt options. By default the call rides out the
+   *   gateway propagation window ({@link DelegatedDecryptOptions.waitForPropagation});
+   *   pass `{ waitForPropagation: false }` to fail fast instead.
+   * @returns Map of encrypted value → clear-text value.
    *
    * @example
    * ```ts
-   * const unwrapTxHash = await wrappedToken.getPendingUnshield();
-   * if (unwrapTxHash) await wrappedToken.resumeUnshield(unwrapTxHash);
+   * const values = await sdk.decryption.delegatedDecryptValues([
+   *   { encryptedValue: balance, contractAddress: tokenAddr },
+   * ], delegatorAddr);
+   * console.log(values[balance]); // 1000n
    * ```
    */
-  getPendingUnshield(): Promise<Hex | null>;
+  delegatedDecryptValues(encryptedInputs: EncryptedInput[], delegatorAddress: Address, accountAddress?: Address, options?: DelegatedDecryptOptions): Promise<Record<EncryptedValue, ClearValue>>;
   /**
-   * Request an unwrap for a specific amount. Encrypts the amount first.
-   * Call {@link finalizeUnwrap} after the request is processed on-chain.
-   *
-   * @param amount - The plaintext amount to unwrap (encrypted automatically).
-   * @returns The transaction hash and mined receipt.
+   * Publicly decrypt one or more FHE encrypted values.
    *
-   * @example
-   * ```ts
-   * const txHash = await wrappedToken.unwrap(500n);
-   * ```
-   */
-  unwrap(amount: bigint): Promise<TransactionResult>;
-  /**
-   * Request an unwrap for the entire confidential balance.
-   * Uses the on-chain encrypted balance directly (no encryption needed).
-   * Throws if the balance is zero.
+   * Signer-independent: works without a configured signer.
+   * Returns the decryption proof alongside the clear-text values so callers
+   * can submit on-chain finalization transactions (e.g. `finalizeUnwrap`).
    *
-   * @returns The transaction hash and mined receipt.
-   * @throws if the balance is zero. {@link DecryptionFailedError}
+   * @param encryptedValues - FHE encrypted values to decrypt publicly.
+   * @param options - Per-call `signal` and `timeout` forwarded to the relayer round-trip.
+   * @returns Clear-text values, ABI-encoded values, and the decryption proof.
    *
    * @example
    * ```ts
-   * const txHash = await wrappedToken.unwrapAll();
+   * const { clearValues, decryptionProof, abiEncodedClearValues } =
+   *   await sdk.decryption.decryptPublicValues([encryptedValue]);
    * ```
    */
-  unwrapAll(): Promise<TransactionResult>;
+  decryptPublicValues(encryptedValues: EncryptedValue[], options?: Pick<FhevmRelayerOptions, "signal" | "timeout">): Promise<DecryptPublicValuesResult>;
   /**
-   * Complete an unwrap by providing the public decryption proof.
-   * Call this after an unshield request has been processed on-chain.
+   * Batch-decrypt delegated encrypted values with per-entry error isolation.
    *
-   * @param unwrapRequestId - `unwrapRequestId` from the `UnwrapRequested` event.
-   * @returns The transaction hash and mined receipt.
+   * Attempts a single batch request first. If the batch fails with a non-fatal
+   * error (e.g. one entry is invalid), falls back to per-entry decryption so
+   * healthy entries still resolve. Each item in the result carries either a
+   * decrypted value or an error — callers decide how to surface partial failures.
    *
-   * @example
-   * ```ts
-   * const event = findUnwrapRequested(receipt.logs);
-   * const txHash = await wrappedToken.finalizeUnwrap(event.unwrapRequestId);
-   * ```
-   */
-  finalizeUnwrap(unwrapRequestId: EncryptedValue): Promise<TransactionResult>;
-}
-//#endregion
-//#region src/wrappers-registry.d.ts
-/**
- * Default wrappers registry addresses for known chains.
- * Only includes chains where a registry is deployed (excludes Hardhat).
- *
- * @deprecated Read `registryAddress` from the chain presets instead (e.g.
- * `sepolia.registryAddress`). Will be removed in the next major version.
- */
-declare const DefaultRegistryAddresses: Record<number, Address>;
-/** Configuration for {@link WrappersRegistry}. */
-interface WrappersRegistryConfig {
-  /** Read-only chain provider used for every registry lookup. */
-  provider: GenericProvider;
-  /**
-   * Per-chain registry address overrides, merged on top of
-   * {@link DefaultRegistryAddresses}. Use this to supply a registry
-   * address for custom or local chains (e.g. Hardhat).
+   * @param encryptedInputs - FHE encrypted values paired with their contract addresses.
+   * @param delegatorAddress - The address that granted delegation rights.
+   * @param accountAddress - The account on whose behalf decryption is performed. Defaults to `delegatorAddress`.
+   * @param maxConcurrency - Maximum parallel decrypt calls during per-entry fallback.
+   * @param waitForPropagation - Ride out the gateway propagation window on the
+   *   initial batch attempt (default `true`). See {@link DelegatedDecryptOptions.waitForPropagation}.
+   * @returns Per-entry results, each with a value or an error.
+   * @throws if no signer is configured. {@link SignerNotConfiguredError}
+   * @throws if signer and provider are on different chains. {@link ChainMismatchError}
    *
    * @example
    * ```ts
-   * new WrappersRegistry({
-   *   provider,
-   *   registryAddresses: { [31337]: "0xYourHardhatRegistry" },
+   * const result = await sdk.decryption.delegatedBatchDecryptValues({
+   *   encryptedInputs: [
+   *     { encryptedValue: encryptedValue1, contractAddress: tokenA },
+   *     { encryptedValue: encryptedValue2, contractAddress: tokenB },
+   *   ],
+   *   delegatorAddress: "0xDelegator",
+   *   maxConcurrency: 5,
    * });
+   * for (const item of result.items) {
+   *   if (item.error) console.error(item.encryptedValue, item.error);
+   *   else console.log(item.encryptedValue, item.value);
+   * }
    * ```
    */
-  registryAddresses?: Record<number, Address>;
-  /**
-   * How long cached registry results remain valid, in seconds.
-   * Default: `86400` (24 hours).
-   */
-  registryTTL?: number;
-}
-/** Options for {@link WrappersRegistry.listPairs}. */
-interface ListPairsOptions {
-  /** Page number (1-indexed). Default: `1`. */
-  page?: number;
-  /** Number of items per page. Default: `100`. */
-  pageSize?: number;
-  /**
-   * When `true`, fetches on-chain metadata (name, symbol, decimals) for both
-   * the ERC-20 and confidential token, plus totalSupply for the ERC-20.
-   * Default: `false`.
-   */
-  metadata?: boolean;
+  delegatedBatchDecryptValues({
+    encryptedInputs,
+    delegatorAddress,
+    accountAddress,
+    maxConcurrency,
+    waitForPropagation
+  }: {
+    encryptedInputs: EncryptedInput[];
+    delegatorAddress: Address;
+    accountAddress?: Address;
+    maxConcurrency?: number;
+  } & DelegatedDecryptOptions): Promise<BatchDecryptResult>;
 }
-/**
- * High-level interface for the on-chain token wrappers registry.
- *
- * Uses the configured {@link GenericProvider} to resolve the correct registry
- * contract address for the current chain and exposes typed read helpers for
- * every registry query. Results are cached in memory with a configurable TTL
- * (default 24 hours).
- *
- * @example
- * ```ts
- * const registry = new WrappersRegistry({ provider });
- *
- * // Paginated listing
- * const page1 = await registry.listPairs({ page: 1, pageSize: 20 });
- *
- * // Structured lookups
- * const result = await registry.getConfidentialToken(erc20Address);
- * if (result) console.log(result.confidentialTokenAddress);
- *
- * // Force refresh
- * registry.refresh();
- * ```
- */
-declare class WrappersRegistry {
-  #private;
-  readonly provider: GenericProvider;
-  constructor(config: WrappersRegistryConfig);
-  /**
-   * Synchronous lookup of the registry address for a given chain ID.
-   * Returns `undefined` if no address is configured for that chain.
-   */
-  getAddress(chainId: number): Address | undefined;
-  /**
-   * Force-invalidate the in-memory cache. The next call to any read method
-   * will fetch fresh data from the chain.
-   */
-  refresh(): void;
-  /**
-   * The cache TTL in milliseconds.
-   * Exposed so query option factories can set a matching `staleTime`.
-   */
-  get ttlMs(): number;
+//#endregion
+//#region src/namespaces/delegations.d.ts
+/**
+ * Public namespace for on-chain decryption-delegation management.
+ *
+ * Exposed as `sdk.delegations`. Owns the SDK-level guards (signer requirement, chain
+ * alignment, delegator address resolution from the wallet account) and delegates the
+ * actual work to the internal {@link DelegationService}.
+ *
+ * Delegation operations write to the host chain ACL; after a delegation is mined,
+ * the gateway syncs the ACL state via cross-chain event propagation — usually
+ * within ~10 blocks (a few seconds). Delegated decryption rides out that window
+ * with a bounded internal retry, so callers can decrypt right after granting.
+ */
+declare class Delegations {
+  #private;
+  /** @internal */
+  constructor(opts: {
+    signer: GenericSigner | undefined;
+    provider: GenericProvider;
+    delegationService: DelegationService;
+  });
   /**
-   * Resolve the registry contract address for the current chain.
+   * Delegate decryption rights for a confidential contract to another address.
+   * Calls `ACL.delegateForUserDecryption()` on-chain.
    *
-   * Priority: `registryAddresses[chainId]` \> built-in default.
+   * The delegation is recorded on L1 immediately, but the gateway must sync the
+   * ACL state via cross-chain event propagation — usually within ~10 blocks (a
+   * few seconds). You do not need to wait: delegated decryption rides out that
+   * window with a bounded internal retry, so you can decrypt right after this
+   * resolves.
    *
-   * @returns The registry contract address for the connected chain.
-   * @throws if no address is configured for the chain. {@link ConfigurationError}
+   * @param contractAddress - The confidential contract address to delegate on.
+   * @param delegateAddress - Address to delegate decryption rights to.
+   * @param expirationDate - Optional expiration date (defaults to permanent delegation via `uint64.max`).
+   * @returns The transaction hash and mined receipt.
+   * @throws if no signer is configured. {@link SignerNotConfiguredError}
+   * @throws if signer and provider are on different chains. {@link ChainMismatchError}
+   * @throws if `expirationDate` is less than 1 hour in the future. {@link DelegationExpirationTooSoonError}
+   * @throws if the delegate equals the connected wallet. {@link DelegationSelfNotAllowedError}
+   * @throws if the delegate equals the contract address. {@link DelegationDelegateEqualsContractError}
+   * @throws if the new expiry equals the current one. {@link DelegationExpiryUnchangedError}
+   * @throws if the delegation transaction reverts. {@link TransactionRevertedError}
    */
-  getRegistryAddress(): Promise<Address>;
+  delegateDecryption({
+    contractAddress,
+    delegateAddress,
+    expirationDate
+  }: {
+    contractAddress: Address;
+    delegateAddress: Address;
+    expirationDate?: Date;
+  }): Promise<TransactionResult>;
   /**
-   * List token wrapper pairs with page-based pagination.
-   *
-   * Internally maps to `getTokenConfidentialTokenPairsSlice` on-chain.
-   *
-   * @param options - Pagination and enrichment options.
-   * @returns A {@link PaginatedResult} of pairs.
-   *
-   * @example
-   * ```ts
-   * const result = await registry.listPairs({ page: 1, pageSize: 20 });
-   * console.log(`${result.total} pairs, showing page ${result.page}`);
+   * Revoke decryption delegation for a confidential contract.
+   * Calls `ACL.revokeDelegationForUserDecryption()` on-chain.
    *
-   * // With on-chain metadata
-   * const withMeta = await registry.listPairs({ metadata: true, pageSize: 10 });
-   * for (const pair of withMeta.items) {
-   *   console.log(pair.underlying.symbol, "→", pair.confidential.symbol);
-   * }
-   * ```
+   * @param contractAddress - The confidential contract address to revoke delegation on.
+   * @param delegateAddress - Address to revoke delegation from.
+   * @returns The transaction hash and mined receipt.
+   * @throws if no signer is configured. {@link SignerNotConfiguredError}
+   * @throws if signer and provider are on different chains. {@link ChainMismatchError}
+   * @throws if no delegation exists for this (delegator, delegate, contract) tuple. {@link DelegationNotFoundError}
+   * @throws if the revocation transaction reverts. {@link TransactionRevertedError}
    */
-  listPairs(options: ListPairsOptions & {
-    metadata: true;
-  }): Promise<PaginatedResult<TokenWrapperPairWithMetadata>>;
-  listPairs(options?: ListPairsOptions): Promise<PaginatedResult<TokenWrapperPair>>;
+  revokeDelegation({
+    contractAddress,
+    delegateAddress
+  }: {
+    contractAddress: Address;
+    delegateAddress: Address;
+  }): Promise<TransactionResult>;
   /**
-   * Look up the confidential token for a given plain ERC-20 address.
+   * Check whether a delegation is active for the given contract address.
    *
-   * @param tokenAddress - The plain ERC-20 token address.
-   * @returns The lookup result, or `null` if the token has never been registered.
-   *   **Note:** revoked tokens (registered then invalidated) return a non-null result
-   *   with `isValid: false`. Check `result.isValid` explicitly rather than using
-   *   `if (result)` to guard against processing revoked tokens.
+   * Signer-independent: works without a configured signer.
    *
-   * @example
-   * ```ts
-   * const result = await registry.getConfidentialToken(usdcAddress);
-   * if (result?.isValid) {
-   *   console.log(result.confidentialTokenAddress);
-   * }
-   * ```
+   * @param contractAddress - The confidential contract address.
+   * @param delegatorAddress - The address that granted the delegation.
+   * @param delegateAddress - The address that received delegation rights.
+   * @returns `true` if the delegation exists and has not expired.
    */
-  getConfidentialToken(tokenAddress: Address): Promise<{
-    confidentialTokenAddress: Address;
-    isValid: boolean;
-  } | null>;
+  isActive(params: {
+    contractAddress: Address;
+    delegatorAddress: Address;
+    delegateAddress: Address;
+  }): Promise<boolean>;
   /**
-   * Reverse lookup — find the plain ERC-20 for a given confidential token.
+   * Get the expiration timestamp of a delegation for the given contract.
    *
-   * @param confidentialTokenAddress - The confidential token address.
-   * @returns The lookup result, or `null` if no pair is registered.
+   * Signer-independent: works without a configured signer.
    *
-   * @example
-   * ```ts
-   * const result = await registry.getUnderlyingToken(cUsdcAddress);
-   * if (result) {
-   *   console.log(result.tokenAddress, result.isValid);
-   * }
-   * ```
+   * @param contractAddress - The confidential contract address.
+   * @param delegatorAddress - The address that granted the delegation.
+   * @param delegateAddress - The address that received delegation rights.
+   * @returns Unix timestamp as bigint. `0n` = no delegation. `2^64 - 1` = permanent.
    */
-  getUnderlyingToken(confidentialTokenAddress: Address): Promise<{
-    tokenAddress: Address;
-    isValid: boolean;
-  } | null>;
+  getExpiry(params: {
+    contractAddress: Address;
+    delegatorAddress: Address;
+    delegateAddress: Address;
+  }): Promise<bigint>;
+}
+//#endregion
+//#region src/namespaces/permits.d.ts
+/**
+ * Public namespace for permit and transport-key-pair management.
+ *
+ * Exposed as `sdk.permits`. Owns the SDK-level guards (chain alignment, empty-array
+ * short-circuit, decrypt-cache invalidation) and delegates the actual work to the
+ * internal {@link CredentialService}.
+ *
+ * The namespace is named `permits` because the user-facing concept is the signed-permit
+ * store. The transport key pair is invisible plumbing — there is no `getTransportKeyPair()`
+ * surfaced; the key pair exists to sign permits and is created automatically when needed.
+ * {@link clear} wipes both the permit store and the transport key pair (permits
+ * cascade-delete with the key pair).
+ */
+declare class Permits {
+  #private;
+  /** @internal */
+  constructor(opts: {
+    signer: GenericSigner | undefined;
+    provider: GenericProvider;
+    cachingService: CachingService;
+    credentialService: CredentialService | undefined;
+    logger: GenericLogger;
+  });
   /**
-   * Fetch all token wrapper pairs from the registry.
+   * Sign and store an EIP-712 permit authorising direct decryption for the
+   * given contract addresses.
    *
-   * @returns All registered `TokenWrapperPair` entries.
+   * Idempotent: if a permit covering the requested set already exists, no
+   * wallet prompt occurs. Otherwise the SDK chunks the uncovered subset into
+   * groups of ≤10 contracts and prompts once per chunk; partial mid-flight
+   * rejection is preserved (already-signed chunks are persisted before the
+   * next prompt).
+   *
+   * @param contracts - Contract addresses to authorize.
    */
-  getTokenPairs(): Promise<readonly TokenWrapperPair[]>;
+  grantPermit(contracts: Address[]): Promise<void>;
   /**
-   * Get the total number of token wrapper pairs.
+   * Sign and store an EIP-712 delegation permit authorising decryption on
+   * behalf of `delegator`. Same idempotence/chunking semantics as {@link grantPermit}.
    *
-   * @returns The count as a bigint.
+   * @param delegator - The address that delegated decryption rights to the connected signer.
+   * @param contracts - Contract addresses to authorize.
    */
-  getTokenPairsLength(): Promise<bigint>;
+  grantDelegationPermit(delegator: Address, contracts: Address[]): Promise<void>;
   /**
-   * Fetch a range of token wrapper pairs (paginated by index).
-   *
-   * @param fromIndex - Start index (inclusive).
-   * @param toIndex - End index (exclusive).
-   * @returns The slice of `TokenWrapperPair` entries.
+   * Pure store lookup: is there a permit covering `contracts`?
+   * No wallet prompt, no transport key pair generation. Returns `false` when no signer
+   * is configured.
    */
-  getTokenPairsSlice(fromIndex: bigint, toIndex: bigint): Promise<readonly TokenWrapperPair[]>;
+  hasPermit(contracts: Address[]): Promise<boolean>;
   /**
-   * Fetch a single token wrapper pair by index.
+   * Pure store lookup for a delegation permit. See {@link hasPermit}.
    *
-   * @param index - Zero-based pair index.
-   * @returns The `TokenWrapperPair` at that index.
+   * @param delegator - The address that delegated decryption rights to the connected signer.
+   * @param contracts - Contract addresses to check.
+   * @returns `true` if cached delegation permits cover all requested contracts.
    */
-  getTokenPair(index: bigint): Promise<TokenWrapperPair>;
+  hasDelegationPermit(delegator: Address, contracts: Address[]): Promise<boolean>;
   /**
-   * Look up the confidential token address for a given plain ERC-20 token.
+   * Best-effort transport-key-pair prefetch for the connected signer.
    *
-   * @param tokenAddress - The plain ERC-20 token address.
-   * @returns A tuple `[isValid, confidentialTokenAddress]`. `isValid` is `true` only for a
-   *   registered, non-revoked wrapper. The address is the zero address when no pair is registered.
-   *   A non-zero address with `isValid=false` means the wrapper was registered but later revoked.
+   * Optional latency optimization: decrypt and permit flows remain correct
+   * without it because they lazily create the transport key pair when needed.
+   *
+   * Silent no-op when no signer is configured or no wallet account is
+   * available. The transport key pair is generated through the relayer dispatcher's
+   * currently active chain — see {@link LifecycleService}, which calls
+   * `switchChain` before fanning the wallet-account change out to listeners,
+   * so any downstream caller (including React adapters) observes the
+   * dispatcher on the wallet chain by the time it invokes warmup.
    */
-  getConfidentialTokenAddress(tokenAddress: Address): Promise<readonly [boolean, Address]>;
+  warmTransportKeyPair(): Promise<void>;
   /**
-   * Reverse lookup — find the plain ERC-20 for a given confidential token.
+   * Wipe FHE permits for the current signer.
    *
-   * @param confidentialTokenAddress - The confidential token address.
-   * @returns A tuple `[isValid, tokenAddress]`. `isValid` is `true` only for a registered,
-   *   non-revoked wrapper. The address is the zero address when no pair is registered.
-   *   A non-zero address with `isValid=false` means the wrapper was registered but later revoked.
+   * - With no argument: every permit referencing this signer is removed across
+   *   all chains and delegators. The transport key pair survives — use {@link clear} to
+   *   also wipe the transport key pair.
+   * - With a contract list: every signed permit in the direct-decrypt scope
+   *   (current chain) whose immutable payload touches any listed address is
+   *   removed. Delegation permits are not touched in this mode.
+   *
+   * @throws if no signer is configured. {@link SignerNotConfiguredError}
    */
-  getTokenAddress(confidentialTokenAddress: Address): Promise<readonly [boolean, Address]>;
+  revokePermits(contracts?: Address[]): Promise<void>;
   /**
-   * Check whether a confidential token is registered and valid.
+   * Wipe the transport key pair for the current signer and cascade-delete every permit
+   * (across chains and delegators) referencing it.
    *
-   * @param confidentialTokenAddress - The confidential token address to check.
-   * @returns `true` if the token is a known valid wrapper in the registry.
+   * @throws if no signer is configured. {@link SignerNotConfiguredError}
    */
-  isConfidentialTokenValid(confidentialTokenAddress: Address): Promise<boolean>;
+  clear(): Promise<void>;
 }
 //#endregion
 //#region src/zama-sdk.d.ts
@@ -20489,8 +20854,6 @@ declare class WrappersRegistry {
  */
 declare class ZamaSDK {
   #private;
-  /** @internal */
-  readonly relayer: RelayerDispatcher;
   readonly provider: GenericProvider;
   readonly signer: GenericSigner | undefined;
   readonly storage: GenericStorage;
@@ -20525,6 +20888,12 @@ declare class ZamaSDK {
    * @internal
    */
   get logger(): GenericLogger;
+  /**
+   * The single-chain relayer backend for the **currently active** chain.
+   *
+   * @internal
+   */
+  get relayer(): FhevmRelayerSDK;
   /**
    * Emit a structured SDK event into the unified SDK event stream.
    *
@@ -20573,7 +20942,7 @@ declare class ZamaSDK {
    * });
    * ```
    */
-  encrypt(params: EncryptParams): Promise<EncryptResult>;
+  encrypt(params: EncryptParams, options?: Pick<FhevmRelayerOptions, "signal" | "timeout">): Promise<EncryptResult>;
   /**
    * Create a high-level ERC-20-style interface for an ERC-7984 confidential token.
    * Supports balance queries, transfers, operator approvals, and decryption.
@@ -20632,5 +21001,5 @@ declare class ZamaSDK {
   [Symbol.dispose](): void;
 }
 //#endregion
-export { DecryptResult as $, BalanceCheckUnavailableError as A, decimalsContract as At, DelegationDelegateEqualsContractError as B, rateContract as Bt, SignerRequiredError as C, ERC7984_WRAPPER_INTERFACE_ID as Ct, NotEntitledError as D, allowanceContract as Dt, RpcRateLimitError as E, supportsInterfaceContract as Et, DecryptionFailedError as F, confidentialTransferContract as Ft, DelegationNotPropagatedError as G, wrapContract as Gt, DelegationExpiredError as H, underlyingContract as Ht, EncryptionFailedError as I, confidentialTransferFromContract as It, NoCiphertextError as J, resolveStorage as Jt, DelegationSelfNotAllowedError as K, ResolvedChainRelayer as Kt, AclPausedError as L, finalizeUnwrapContract as Lt, ERC20ReadFailedError as M, symbolContract as Mt, InsufficientConfidentialBalanceError as N, confidentialBalanceOfContract as Nt, ConfigurationError as O, approveContract as Ot, InsufficientERC20BalanceError as P, confidentialTotalSupplyContract as Pt, ZamaErrorCode as Q, DelegationContractIsSelfError as R, inferredTotalSupplyContract as Rt, SignerNotConfiguredError as S, ERC7984_INTERFACE_ID as St, WalletNotConnectedError as T, isConfidentialWrapperContract as Tt, DelegationExpiryUnchangedError as U, unwrapContract as Ut, DelegationExpirationTooSoonError as V, setOperatorContract as Vt, DelegationNotFoundError as W, unwrapFromBalanceContract as Wt, ChainMismatchError as X, TransportKeyPairExpiredError as Y, createConfig as Yt, ZamaError as Z, WorkerRecycledError as _, getDelegationExpiryContract as _t, WrappersRegistryConfig as a, QueryFactoryOptions as at, SigningFailedError as b, transferAndCallContract as bt, BatchDecryptAsOptions as c, TokenWrapperPairWithMetadata as ct, Delegations as d, getTokenPairContract as dt, EncryptedInput as et, Decryption as f, getTokenPairsContract as ft, matchZamaError as g, delegateForUserDecryptionContract as gt, DelegatedDecryptOptions as h, isConfidentialTokenValidContract as ht, WrappersRegistry as i, MutationFactoryOptions as it, BalanceErrorDetails as j, nameContract as jt, RelayerRequestFailedError as k, balanceOfContract as kt, Token as l, getConfidentialTokenAddressContract as lt, BatchDecryptResult as m, getTokenPairsSliceContract as mt, DefaultRegistryAddresses as n, SignerQueryContext as nt, WrappedToken as o, PaginatedResult as ot, BatchDecryptItem as p, getTokenPairsLengthContract as pt, InvalidTransportKeyPairError as q, resolveChainRelayers as qt, ListPairsOptions as r, zamaQueryKeys as rt, BatchBalancesResult as s, TokenWrapperPair as st, ZamaSDK as t, decryptValuesQueryOptions as tt, Permits as u, getTokenAddressContract as ut, WorkerTimeoutError as v, isHandleDelegatedContract as vt, WalletAccountNotReadyError as w, isConfidentialTokenContract as wt, SigningRejectedError as x, ERC1363_INTERFACE_ID as xt, TransactionRevertedError as y, revokeDelegationContract as yt, DelegationCooldownError as z, isOperatorContract as zt };
-//# sourceMappingURL=index-C1Mtc8Rw.d.ts.map
+export { confidentialTransferMutationOptions as $, getTokenAddressContract as $n, DelegationSelfNotAllowedError as $t, encryptMutationOptions as A, QueryFilterLike as An, setOperatorContract as Ar, SignerRequiredError as At, UnshieldParams as B, invalidateWagmiBalanceQueries as Bn, InsufficientConfidentialBalanceError as Bt, grantPermitMutationOptions as C, IsConfidentialQueryConfig as Cn, confidentialTotalSupplyContract as Cr, BatchDecryptAsOptions as Ct, DecryptResult as D, TokenMetadataQueryConfig as Dn, inferredTotalSupplyContract as Dr, SigningFailedError as Dt, delegatedDecryptValuesMutationOptions as E, TokenMetadata as En, finalizeUnwrapContract as Er, TransactionRevertedError as Et, unwrapMutationOptions as F, invalidateAfterTransfer as Fn, ResolvedChainRelayer as Fr, ConfigurationError as Ft, confidentialSetOperatorMutationOptions as G, QueryFactoryOptions as Gn, DelegationContractIsSelfError as Gt, ApproveUnderlyingParams as H, zamaQueryKeys as Hn, DecryptionFailedError as Ht, ResumeUnshieldParams as I, invalidateAfterUnshield as In, resolveChainRelayers as Ir, RelayerRequestFailedError as It, ConfidentialTransferFromParams as J, hashFn as Jn, DelegationExpirationTooSoonError as Jt, ConfidentialTransferFromAndCallParams as K, StrippedQueryOptionKeys as Kn, DelegationCooldownError as Kt, resumeUnshieldMutationOptions as L, invalidateAfterUnshieldSettled as Ln, resolveStorage as Lr, BalanceCheckUnavailableError as Lt, finalizeUnwrapMutationOptions as M, invalidateAfterApproveUnderlying as Mn, unwrapContract as Mr, WalletNotConnectedError as Mt, unwrapAllMutationOptions as N, invalidateAfterSetOperator as Nn, unwrapFromBalanceContract as Nr, RpcRateLimitError as Nt, EncryptedInput as O, tokenMetadataQueryOptions as On, isOperatorContract as Or, SigningRejectedError as Ot, UnwrapParams as P, invalidateAfterShield as Pn, wrapContract as Pr, NotEntitledError as Pt, ConfidentialTransferParams as Q, getConfidentialTokenAddressContract as Qn, DelegationNotPropagatedError as Qt, UnshieldAllParams as R, invalidateAfterUnwrap as Rn, createConfig as Rr, BalanceErrorDetails as Rt, hasPermitQueryOptions as S, totalSupplyQueryOptions as Sn, confidentialBalanceOfContract as Sr, BatchBalancesResult as St, DelegatedDecryptValuesMutationParams as T, isWrapperQueryOptions as Tn, confidentialTransferFromContract as Tr, matchZamaError as Tt, approveUnderlyingMutationOptions as U, SignerQueryContext as Un, EncryptionFailedError as Ut, unshieldMutationOptions as V, invalidateWalletLifecycleQueries as Vn, InsufficientERC20BalanceError as Vt, ConfidentialSetOperatorParams as W, MutationFactoryOptions as Wn, AclPausedError as Wt, ConfidentialTransferAndCallParams as X, TokenWrapperPair as Xn, DelegationExpiryUnchangedError as Xt, confidentialTransferFromMutationOptions as Y, PaginatedResult as Yn, DelegationExpiredError as Yt, confidentialTransferAndCallMutationOptions as Z, TokenWrapperPairWithMetadata as Zn, DelegationNotFoundError as Zt, DelegateDecryptionParams as _, WrappersRegistryConfig as _n, approveContract as _r, ConfidentialBalancesQueryConfig as _t, BatchDecryptItem as a, ZamaErrorCode as an, delegateForUserDecryptionContract as ar, TokenAddressQueryConfig as at, revokePermitsMutationOptions as b, StoredTransportKeyPair as bn, nameContract as br, confidentialBalanceQueryOptions as bt, DelegationStatusData as c, PendingUnshieldQueryConfig as cn, revokeDelegationContract as cr, WrappersRegistryQueryConfig as ct, RevokeDelegationParams as d, underlyingAllowanceQueryOptions as dn, ERC7984_INTERFACE_ID as dr, listPairsQueryOptions as dt, InvalidTransportKeyPairError as en, getTokenPairContract as er, ShieldParams as et, revokeDelegationMutationOptions as f, WrapperDiscoveryQueryConfig as fn, ERC7984_WRAPPER_INTERFACE_ID as fr, tokenAddressQueryOptions as ft, decryptBalanceAsMutationOptions as g, WrappersRegistry as gn, allowanceContract as gr, tokenPairsSliceQueryOptions as gt, DecryptBalanceAsParams as h, ListPairsOptions as hn, supportsInterfaceContract as hr, tokenPairsQueryOptions as ht, Decryption as i, ZamaError as in, isConfidentialTokenValidContract as ir, ListPairsQueryConfig as it, FinalizeUnwrapParams as j, QueryLike as jn, underlyingContract as jr, WalletAccountNotReadyError as jt, decryptValuesQueryOptions as k, QueryClientLike as kn, rateContract as kr, SignerNotConfiguredError as kt, DelegationStatusQueryConfig as l, pendingUnshieldQueryOptions as ln, transferAndCallContract as lr, confidentialTokenAddressQueryOptions as lt, batchDecryptBalancesAsMutationOptions as m, DefaultRegistryAddresses as mn, isConfidentialWrapperContract as mr, tokenPairsLengthQueryOptions as mt, Permits as n, TransportKeyPairExpiredError as nn, getTokenPairsLengthContract as nr, ConfidentialTokenAddressQueryConfig as nt, BatchDecryptResult as o, ConfidentialIsOperatorQueryConfig as on, getDelegationExpiryContract as or, TokenPairQueryConfig as ot, BatchDecryptBalancesAsParams as p, wrapperDiscoveryQueryOptions as pn, isConfidentialTokenContract as pr, tokenPairQueryOptions as pt, confidentialTransferFromAndCallMutationOptions as q, filterQueryOptions as qn, DelegationDelegateEqualsContractError as qt, Delegations as r, ChainMismatchError as rn, getTokenPairsSliceContract as rr, IsConfidentialTokenValidQueryConfig as rt, DelegatedDecryptOptions as s, confidentialIsOperatorQueryOptions as sn, isHandleDelegatedContract as sr, TokenPairsSliceQueryConfig as st, ZamaSDK as t, NoCiphertextError as tn, getTokenPairsContract as tr, shieldMutationOptions as tt, delegationStatusQueryOptions as u, UnderlyingAllowanceQueryConfig as un, ERC1363_INTERFACE_ID as ur, isConfidentialTokenValidQueryOptions as ut, delegateDecryptionMutationOptions as v, Permission as vn, balanceOfContract as vr, confidentialBalancesQueryOptions as vt, decryptPublicValuesMutationOptions as w, isConfidentialQueryOptions as wn, confidentialTransferContract as wr, Token as wt, HasPermitQueryConfig as x, TotalSupplyQueryConfig as xn, symbolContract as xr, WrappedToken as xt, clearCredentialsMutationOptions as y, SerializedTransportKeyPair as yn, decimalsContract as yr, ConfidentialBalanceQueryConfig as yt, unshieldAllMutationOptions as z, invalidateBalanceQueries as zn, ERC20ReadFailedError as zt };
+//# sourceMappingURL=zama-sdk-q4_qt64Q.d.ts.map