@zama-fhe/sdk 3.4.0-alpha.8 → 3.4.0

package/dist/esm/{index-C4Hn6K9c.d.ts → index-DLaQtvYu.d.ts}

@@ -1,9 +1,9 @@
-import { u as FheChain } from "./index-doNE2KoX.js";
-import { C as ChainRouter, Ft as TransactionResult, Gt as FhevmRelayerOptions, Ht as EncryptResult, It as ClearValue, Kt as FhevmRelayerSDK, Lt as DecryptPublicValuesResult, Q as ShieldOptions, R as TransactionOperation, Ut as EncryptedValue, Vt as EncryptParams, at as TransferCallbacks, c as GenericStorage, d as WalletAccount, et as TransferOptions, i as ZamaConfig, l as GenericProvider, n as RelayerConfig, nt as UnwrapResult, o as ZamaConfigGeneric, ot as UnshieldCallbacks, p as WalletAccountListener, q as ZamaSDKEventInput, rt as WrapOptions, s as GenericLogger, tt as UnshieldOptions, u as GenericSigner, x as WriteContractConfig } from "./types-CELdIAFG.js";
-import "./cleartext-_RCZVPOe.js";
-import "./types-DlSUyFe2.js";
-import "./base-signer-Ds8CoYy0.js";
-import "./types-Tk8PiPCk.js";
+import { u as FheChain } from "./index-S6_V7aAH.js";
+import { $ as UnshieldOptions, Bt as EncryptResult, Ft as DecryptPublicValuesResult, Nt as TransactionResult, Pt as ClearValue, Q as TransferOptions, Vt as EncryptedValue, Wt as FhevmRelayerOptions, X as ShieldOptions, c as GenericStorage, d as WalletAccount, et as UnwrapResult, i as ZamaConfig, it as UnshieldCallbacks, l as GenericProvider, o as ZamaConfigGeneric, qt as RelayerSDK, rt as TransferCallbacks, tt as WrapOptions, u as GenericSigner, zt as EncryptParams } from "./types-CWPSTRF6.js";
+import "./cleartext-CxlICeUh.js";
+import "./types-Dr7AmEs1.js";
+import "./base-signer-BvL-jMNO.js";
+import "./types-BEz-VgR_.js";
 import { Address, Address as Address$1, Hex, Hex as Hex$1 } from "viem";
 import { z } from "zod/mini";
 import { MutationFunctionContext, QueryKey, QueryObserverOptions, skipToken } from "@tanstack/query-core";
@@ -33,17 +33,6 @@ import { MutationFunctionContext, QueryKey, QueryObserverOptions, skipToken } fr
  */
 declare function createConfig<const TChains extends readonly [FheChain, ...FheChain[]]>(params: ZamaConfigGeneric<TChains>): ZamaConfig;
 //#endregion
-//#region src/config/resolve.d.ts
-declare function resolveStorage(storage?: GenericStorage | undefined, permitStorage?: GenericStorage | undefined): {
-  storage: GenericStorage;
-  permitStorage: GenericStorage;
-};
-interface ResolvedChainRelayer {
-  chain: FheChain;
-  relayerConfig: RelayerConfig;
-}
-declare function resolveChainRelayers(chains: readonly FheChain[], relayers: Readonly<Record<number, RelayerConfig>>): Map<number, ResolvedChainRelayer>;
-//#endregion
 //#region src/contracts/confidential-wrapper.d.ts
 /**
  * Returns the contract config to read an encrypted balance.
@@ -17089,19 +17078,25 @@ declare function isHandleDelegatedContract(aclAddress: Address, delegatorAddress
 };
 //#endregion
 //#region src/contracts/wrappers-registry.d.ts
+/** A registered plain-token / confidential-token pairing from the wrappers registry. */
 interface TokenWrapperPair {
+  /** Address of the underlying public ERC-20 token. */
   readonly tokenAddress: Address;
+  /** Address of the paired confidential (ERC-7984) token. */
   readonly confidentialTokenAddress: Address;
+  /** Whether the pairing is currently valid (registered and not revoked). */
   readonly isValid: boolean;
 }
 /** Extended pair with on-chain metadata for both tokens. */
 interface TokenWrapperPairWithMetadata extends TokenWrapperPair {
+  /** On-chain metadata of the underlying public ERC-20 token. */
   readonly underlying: {
     readonly name: string;
     readonly symbol: string;
     readonly decimals: number;
     readonly totalSupply: bigint;
   };
+  /** On-chain metadata of the confidential token. */
   readonly confidential: {
     readonly name: string;
     readonly symbol: string;
@@ -17110,9 +17105,13 @@ interface TokenWrapperPairWithMetadata extends TokenWrapperPair {
 }
 /** Paginated result set modelled after standard API pagination. */
 interface PaginatedResult<T> {
+  /** Items on the current page. */
   readonly items: readonly T[];
+  /** Total number of items across all pages. */
   readonly total: number;
+  /** One-based index of the current page. */
   readonly page: number;
+  /** Maximum number of items per page. */
   readonly pageSize: number;
 }
 /**
@@ -18460,13 +18459,21 @@ declare function isConfidentialTokenValidContract(registry: Address, confidentia
 };
 //#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"> & {
+/**
+ * TanStack Query options object returned by the SDK's `*QueryOptions` factories:
+ * `QueryObserverOptions` with `queryKey` and `queryFn` required and the
+ * cache-internal keys (`queryHash`, `queryKeyHashFn`, `throwOnError`) removed.
+ */
+type QueryFactoryOptions<TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, "queryKey"> & Required<Pick<QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, "queryKey">>, "queryFn" | "queryHash" | "queryKeyHashFn" | "throwOnError"> & {
   queryFn: Exclude<QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>["queryFn"], typeof skipToken | undefined>;
 };
+/** TanStack Query mutation options object returned by the SDK's `*MutationOptions` factories. */
 interface MutationFactoryOptions<TMutationKey extends readonly unknown[], TVariables, TData, TOnMutateResult = unknown> {
+  /** Cache key identifying the mutation. */
   mutationKey: TMutationKey;
+  /** Runs the mutation for the given variables. */
   mutationFn: (variables: TVariables) => Promise<TData>;
+  /** Optional callback invoked after the mutation succeeds. */
   onSuccess?: (data: TData, variables: TVariables, onMutateResult: TOnMutateResult, context: MutationFunctionContext) => void;
 }
 //#endregion
@@ -18674,229 +18681,25 @@ declare const zamaQueryKeys: {
 };
 //#endregion
 //#region src/query/signer-query-context.d.ts
+/** Connected-wallet context threaded into query factories to scope cache keys and gate signer-dependent queries. */
 interface SignerQueryContext {
+  /** Connected wallet account; queries that need a signer stay disabled until it is set. */
   walletAccount?: WalletAccount;
 }
 //#endregion
 //#region src/query/user-decrypt.d.ts
+/** A single encrypted value to decrypt, paired with the contract that owns it. */
 interface EncryptedInput {
+  /** Encrypted handle to decrypt. */
   encryptedValue: EncryptedValue;
+  /** Address of the contract the encrypted value belongs to. */
   contractAddress: Address;
 }
 /** Decrypted clear values keyed by encrypted handle. */
 type DecryptResult = Readonly<Record<EncryptedValue, ClearValue>>;
+/** Builds TanStack Query options for decrypting a batch of encrypted handles into their clear values. */
 declare function decryptValuesQueryOptions(sdk: ZamaSDK, encryptedInputs: EncryptedInput[], signerContext?: SignerQueryContext): QueryFactoryOptions<DecryptResult, Error, DecryptResult, ReturnType<typeof zamaQueryKeys.decryption.encryptedInputs>>;
 //#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
-/**
- * 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/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;
-  /**
-   * Opt-in shared-tenant scope (B2B2C/WaaS operators). When set, every signer
-   * configured with the same scope shares one transport key pair instead of one
-   * per signer address. Permits stay per-signer regardless — see
-   * {@link revokeTransportKeyPair} for the operator-level counterpart to
-   * signer-level revocation.
-   */
-  scope?: string;
-}
-/**
- * Single facade coordinating the keypair vault and the permission store.
- *
- * `CredentialService` is the only credentials object held by `ZamaSDK`. It accepts identity
- * transitions via `handleWalletAccountChange`.
- *
- * Two distinct revocation tiers exist and must not be conflated: {@link clearCredentials}
- * (signer-level, e.g. an end-user "disconnect") only ever removes that signer's own
- * key-pair slot and permits — when a scope is configured, the shared key pair was never
- * stored there, so it's untouched. {@link revokeTransportKeyPair} (operator-level) is
- * the only way to invalidate a scope's shared key pair, and it does so for every signer
- * in the scope at once.
- */
-declare class CredentialService {
-  #private;
-  constructor(config: CredentialServiceConfig);
-  /**
-   * 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 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}
-   */
-  grantPermit(contracts: readonly Address[], delegator?: Address): Promise<SerializedTransportKeyPairWithPermissions>;
-  /**
-   * Pure store lookup: are stored permits sufficient to cover `contracts`? No wallet prompt.
-   *
-   * @returns `true` if cached permits cover all requested contracts (vacuously
-   *   true for an empty list); `false` if no keypair exists or coverage is
-   *   incomplete.
-   */
-  hasPermit(contracts: readonly Address[], delegator?: Address): Promise<boolean>;
-  /**
-   * Wipe FHE permits for the current signer.
-   *
-   * - 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.
-   *
-   * @throws if reading the signer address fails. {@link SigningFailedError}
-   */
-  revokePermits(contracts?: readonly Address[]): Promise<void>;
-  /**
-   * Wipe the keypair for the current signer and cascade-delete every
-   * permission referencing it across all chains and delegators.
-   *
-   * Signer-level only: when a scope is configured, the shared key pair was never
-   * stored under this signer's own slot, so it survives untouched — only this
-   * signer's permits are removed. Use {@link revokeTransportKeyPair} to invalidate
-   * the shared key pair itself.
-   *
-   * @throws if reading the signer address fails. {@link SigningFailedError}
-   */
-  clearCredentials(): Promise<void>;
-  /**
-   * Revoke this scope's shared transport key pair (operator-level action).
-   *
-   * Deletes the shared key pair. Every permit signed under it embeds the old
-   * public key, so `listUsableAndPrune` treats them all as stale on next access —
-   * no permit is touched directly, and no connected wallet is required. This is
-   * the only operation that can invalidate a shared key pair; signer-level
-   * {@link clearCredentials} never does.
-   *
-   * Not best-effort: unlike {@link clearCredentials}, a storage failure here rejects
-   * instead of being logged and swallowed — see {@link TransportKeyPairVault.clearScope}.
-   *
-   * Only stops the SDK from reissuing or reusing the deleted key going forward — does
-   * not revoke any permit already issued under it. A permit is a self-contained,
-   * bearer-style EIP-712 signature the relayer accepts independently of this SDK's
-   * storage; one already exfiltrated alongside the key remains usable until its own
-   * `permitTTL` expiry regardless of this call.
-   *
-   * @param scopeId - Must match the scope this service was configured with. Requiring
-   *   the caller to name it guards against revoking the wrong scope by mistake.
-   * @throws if no scope is configured, or `scopeId` doesn't match it. {@link ConfigurationError}
-   * @throws if the underlying storage delete fails.
-   */
-  revokeTransportKeyPair(scopeId: string): Promise<void>;
-  /**
-   * Warm the signer transport key pair cache for a known address.
-   *
-   * 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.
-   *
-   * Not for pre-warming a shared scope: `address` is ignored for storage keying once
-   * a scope is configured (see {@link TransportKeyPairVault}), so this call's actual
-   * effect wouldn't match its apparent per-signer intent. Use
-   * {@link warmTransportKeyPairScope} instead.
-   */
-  warmTransportKeyPair(address: Address): Promise<void>;
-  /**
-   * Warm this scope's shared transport key pair (operator-level, no wallet needed) —
-   * the pre-warm counterpart to {@link revokeTransportKeyPair}.
-   *
-   * @param scopeId - Must match the scope this service was configured with. Requiring
-   *   the caller to name it guards against warming the wrong scope by mistake.
-   * @throws if no scope is configured, or `scopeId` doesn't match it. {@link ConfigurationError}
-   */
-  warmTransportKeyPairScope(scopeId: string): Promise<void>;
-  /**
-   * Apply a wallet account transition.
-   *
-   * 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`.
-   */
-  handleWalletAccountChange(prev?: {
-    address: Address;
-  }, next?: {
-    address: Address;
-  }): Promise<void>;
-}
-//#endregion
 //#region src/errors/base.d.ts
 /**
  * Typed error codes thrown by the SDK.
@@ -19057,8 +18860,11 @@ declare function retryAfterSeconds(error: unknown): number | undefined;
  * ```
  */
 declare class ChainMismatchError extends ZamaError {
+  /** Name of the operation that triggered the check. */
   readonly operation: string;
+  /** Chain ID the signer is connected to. */
   readonly signerChainId: number;
+  /** Chain ID the provider is connected to. */
   readonly providerChainId: number;
   constructor({ operation, signerChainId, providerChainId }: {
     operation: string;
@@ -19158,8 +18964,11 @@ declare class DecryptionFailedError extends ZamaError {
 //#region src/errors/balance.d.ts
 /** Structured details shared by balance-related errors. */
 interface BalanceErrorDetails {
+  /** Amount the caller requested, in the token's base units. */
   readonly requested: bigint;
+  /** Amount available at the time of the check, in the token's base units. */
   readonly available: bigint;
+  /** Address of the token contract involved. */
   readonly token: Address;
 }
 /** Confidential (cToken) balance is insufficient for the requested operation. */
@@ -19297,6 +19106,7 @@ declare class RpcRateLimitError extends ZamaError {
  * Base class for signer/account readiness failures.
  */
 declare class SignerRequiredError extends ZamaError {
+  /** Name of the operation that required a signer. */
   readonly operation: string;
   constructor(code: ZamaErrorCode, operation: string, message: string, options?: ErrorOptions);
 }
@@ -19346,51 +19156,75 @@ declare class TransactionRevertedError extends ZamaError {
 }
 //#endregion
 //#region src/errors/match.d.ts
-/**
- * Identity type that fails to instantiate unless `T` maps every code to a `ZamaError`.
- * Guards presence + value type only: a wrong-but-valid mapping (a code pointing at a
- * structurally identical sibling class) still compiles — `errors.test-d.ts` backstops that.
- */
-type Complete<T extends Record<ZamaErrorCode, ZamaError>> = T;
 /**
  * Maps each {@link ZamaErrorCode} to the error class thrown with that code, so
  * {@link matchZamaError} handlers receive the matched subtype instead of the base
- * `ZamaError`. Hand-maintained; the `Complete` wrapper fails the build if a code is
- * added without an entry here (or mapped to a non-`ZamaError`).
+ * `ZamaError`.
  */
-type ErrorForCode = Complete<{
+interface ErrorForCode {
+  /** Thrown for {@link ZamaErrorCode.SigningRejected}. */
   [ZamaErrorCode.SigningRejected]: SigningRejectedError;
+  /** Thrown for {@link ZamaErrorCode.SigningFailed}. */
   [ZamaErrorCode.SigningFailed]: SigningFailedError;
+  /** Thrown for {@link ZamaErrorCode.EncryptionFailed}. */
   [ZamaErrorCode.EncryptionFailed]: EncryptionFailedError;
+  /** Thrown for {@link ZamaErrorCode.DecryptionFailed}. */
   [ZamaErrorCode.DecryptionFailed]: DecryptionFailedError;
+  /** Thrown for {@link ZamaErrorCode.TransactionReverted}. */
   [ZamaErrorCode.TransactionReverted]: TransactionRevertedError;
+  /** Thrown for {@link ZamaErrorCode.TransportKeyPairExpired}. */
   [ZamaErrorCode.TransportKeyPairExpired]: TransportKeyPairExpiredError;
+  /** Thrown for {@link ZamaErrorCode.InvalidTransportKeyPair}. */
   [ZamaErrorCode.InvalidTransportKeyPair]: InvalidTransportKeyPairError;
+  /** Thrown for {@link ZamaErrorCode.NoCiphertext}. */
   [ZamaErrorCode.NoCiphertext]: NoCiphertextError;
+  /** Thrown for {@link ZamaErrorCode.RelayerRequestFailed}. */
   [ZamaErrorCode.RelayerRequestFailed]: RelayerRequestFailedError;
+  /** Thrown for {@link ZamaErrorCode.NotEntitled}. */
   [ZamaErrorCode.NotEntitled]: NotEntitledError;
+  /** Thrown for {@link ZamaErrorCode.RpcRateLimited}. */
   [ZamaErrorCode.RpcRateLimited]: RpcRateLimitError;
+  /** Thrown for {@link ZamaErrorCode.Configuration}. */
   [ZamaErrorCode.Configuration]: ConfigurationError;
+  /** Thrown for {@link ZamaErrorCode.DelegationSelfNotAllowed}. */
   [ZamaErrorCode.DelegationSelfNotAllowed]: DelegationSelfNotAllowedError;
+  /** Thrown for {@link ZamaErrorCode.DelegationCooldown}. */
   [ZamaErrorCode.DelegationCooldown]: DelegationCooldownError;
+  /** Thrown for {@link ZamaErrorCode.DelegationNotFound}. */
   [ZamaErrorCode.DelegationNotFound]: DelegationNotFoundError;
+  /** Thrown for {@link ZamaErrorCode.DelegationExpired}. */
   [ZamaErrorCode.DelegationExpired]: DelegationExpiredError;
+  /** Thrown for {@link ZamaErrorCode.InsufficientConfidentialBalance}. */
   [ZamaErrorCode.InsufficientConfidentialBalance]: InsufficientConfidentialBalanceError;
+  /** Thrown for {@link ZamaErrorCode.InsufficientERC20Balance}. */
   [ZamaErrorCode.InsufficientERC20Balance]: InsufficientERC20BalanceError;
+  /** Thrown for {@link ZamaErrorCode.InsufficientAllowance}. */
   [ZamaErrorCode.InsufficientAllowance]: InsufficientAllowanceError;
+  /** Thrown for {@link ZamaErrorCode.BalanceCheckUnavailable}. */
   [ZamaErrorCode.BalanceCheckUnavailable]: BalanceCheckUnavailableError;
+  /** Thrown for {@link ZamaErrorCode.ERC20ReadFailed}. */
   [ZamaErrorCode.ERC20ReadFailed]: ERC20ReadFailedError;
+  /** Thrown for {@link ZamaErrorCode.DelegationExpiryUnchanged}. */
   [ZamaErrorCode.DelegationExpiryUnchanged]: DelegationExpiryUnchangedError;
+  /** Thrown for {@link ZamaErrorCode.DelegationDelegateEqualsContract}. */
   [ZamaErrorCode.DelegationDelegateEqualsContract]: DelegationDelegateEqualsContractError;
+  /** Thrown for {@link ZamaErrorCode.DelegationContractIsSelf}. */
   [ZamaErrorCode.DelegationContractIsSelf]: DelegationContractIsSelfError;
+  /** Thrown for {@link ZamaErrorCode.AclPaused}. */
   [ZamaErrorCode.AclPaused]: AclPausedError;
+  /** Thrown for {@link ZamaErrorCode.DelegationExpirationTooSoon}. */
   [ZamaErrorCode.DelegationExpirationTooSoon]: DelegationExpirationTooSoonError;
+  /** Thrown for {@link ZamaErrorCode.DelegationNotPropagated}. */
   [ZamaErrorCode.DelegationNotPropagated]: DelegationNotPropagatedError;
+  /** Thrown for {@link ZamaErrorCode.ChainMismatch}. */
   [ZamaErrorCode.ChainMismatch]: ChainMismatchError;
+  /** Thrown for {@link ZamaErrorCode.SignerNotConfigured}. */
   [ZamaErrorCode.SignerNotConfigured]: SignerNotConfiguredError;
+  /** Thrown for {@link ZamaErrorCode.WalletNotConnected}. */
   [ZamaErrorCode.WalletNotConnected]: WalletNotConnectedError;
+  /** Thrown for {@link ZamaErrorCode.WalletAccountNotReady}. */
   [ZamaErrorCode.WalletAccountNotReady]: WalletAccountNotReadyError;
-}>;
+}
 /**
  * Pattern-match on a {@link ZamaError} by its error code. Each handler receives the
  * error class for its code, so subclass fields are available without a cast.
@@ -19411,57 +19245,6 @@ 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, 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 {
@@ -19473,35 +19256,22 @@ interface DelegatedDecryptOptions {
    */
   waitForPropagation?: boolean;
 }
+/** Per-handle outcome of a batch decrypt: the decrypted value, or a per-item error. */
 interface BatchDecryptItem {
+  /** The encrypted value (handle) being decrypted. */
   encryptedValue: EncryptedValue;
+  /** Address of the contract the handle belongs to. */
   contractAddress: Address;
+  /** Decrypted clear value; set when this item succeeded. */
   value?: ClearValue;
+  /** Error for this item; set when this item failed. */
   error?: ZamaError;
 }
+/** Result of a batch decrypt: one entry per requested handle, in input order. */
 interface BatchDecryptResult {
+  /** Per-handle outcomes. */
   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
 /**
@@ -19529,13 +19299,6 @@ declare class DecryptionService {
  */
 declare class Decryption {
   #private;
-  /** @internal */
-  constructor(opts: {
-    signer: GenericSigner | undefined;
-    provider: GenericProvider;
-    router: ChainRouter;
-    decryptionService: DecryptionService | undefined;
-  });
   /**
    * Decrypt one or more FHE encrypted values. Results are cached — repeated calls
    * for the same encrypted value skip the relayer round-trip.
@@ -19647,6 +19410,15 @@ declare class Decryption {
   } & DelegatedDecryptOptions): Promise<BatchDecryptResult>;
 }
 //#endregion
+//#region src/services/delegation-service.d.ts
+/** Delegation activity and expiry, resolved from a single expiry read. */
+interface DelegationStatus {
+  /** Whether the delegation is currently active (exists and not expired). */
+  isActive: boolean;
+  /** Unix timestamp (seconds) when the delegation expires; `0n` if none exists. */
+  expiryTimestamp: bigint;
+}
+//#endregion
 //#region src/namespaces/delegations.d.ts
 /**
  * Public namespace for on-chain decryption-delegation management.
@@ -19662,12 +19434,6 @@ declare class Decryption {
  */
 declare class Delegations {
   #private;
-  /** @internal */
-  constructor(opts: {
-    signer: GenericSigner | undefined;
-    provider: GenericProvider;
-    delegationService: DelegationService;
-  });
   /**
    * Delegate decryption rights for a confidential contract to another address.
    * Calls `ACL.delegateForUserDecryption()` on-chain.
@@ -19741,6 +19507,22 @@ declare class Delegations {
     delegatorAddress: Address;
     delegateAddress: Address;
   }): Promise<bigint>;
+  /**
+   * Get activity and expiry together in a single on-chain read, instead of
+   * calling {@link isActive} and {@link getExpiry} separately.
+   *
+   * Signer-independent: works without a configured signer.
+   *
+   * @param contractAddress - The confidential contract address.
+   * @param delegatorAddress - The address that granted the delegation.
+   * @param delegateAddress - The address that received delegation rights.
+   * @returns `{ isActive, expiryTimestamp }` — activity and the raw expiry timestamp together.
+   */
+  getStatus(params: {
+    contractAddress: Address;
+    delegatorAddress: Address;
+    delegateAddress: Address;
+  }): Promise<DelegationStatus>;
 }
 //#endregion
 //#region src/namespaces/permits.d.ts
@@ -19764,14 +19546,6 @@ declare class Delegations {
  */
 declare class Permits {
   #private;
-  /** @internal */
-  constructor(opts: {
-    signer: GenericSigner | undefined;
-    provider: GenericProvider;
-    cachingService: CachingService;
-    credentialService: CredentialService | undefined;
-    logger: GenericLogger;
-  });
   /**
    * Sign and store an EIP-712 permit authorising direct decryption for the
    * given contract addresses.
@@ -19930,7 +19704,9 @@ interface BatchBalancesResult {
  */
 declare class Token {
   #private;
+  /** The SDK instance this token operates through. */
   readonly sdk: ZamaSDK;
+  /** Checksummed address of the confidential token contract. */
   readonly address: Address;
   constructor(sdk: ZamaSDK, address: Address);
   /** Read the token name from the contract. */
@@ -20175,39 +19951,6 @@ declare class Token {
    * ```
    */
   isOperator(holder: Address, spender: Address): Promise<boolean>;
-  /**
-   * Read the on-chain encrypted balance for a given owner.
-   *
-   * @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.
-   *
-   * @internal
-   */
-  protected assertConfidentialBalance(amount: bigint): Promise<void>;
-  /**
-   * Emit a token-scoped event through the owning {@link ZamaSDK} so that
-   * subscribers see a unified stream.
-   *
-   * @internal
-   */
-  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;
 }
@@ -20430,6 +20173,84 @@ declare class WrappedToken extends Token {
   finalizeUnwrap(unwrapRequestId: EncryptedValue): Promise<TransactionResult>;
 }
 //#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/types.d.ts
+/**
+ * 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 {
+  /** ML-KEM public key, hex-encoded. */
+  publicKey: Hex;
+  /** ML-KEM private key, hex-encoded (plaintext — treat as sensitive). */
+  privateKey: Hex;
+  /**
+   * The TKMS version the key pair was generated under, passed back to
+   * `parseTransportKeyPair` so the private key deserializes under the right
+   * version after a KMS/TKMS rotation. Optional — key pairs serialized before
+   * this tag existed carry none.
+   */
+  tkmsVersion?: string;
+}
+/** EIP-712 typed-data payload carried by a {@link SerializedPermit}. */
+interface SerializedPermitEip712 {
+  /** EIP-712 domain separator fields. */
+  domain: Record<string, unknown>;
+  /** Name of the primary type being signed. */
+  primaryType?: string;
+  /** EIP-712 type definitions keyed by type name. */
+  types: Record<string, {
+    name: string;
+    type: string;
+  }[]>;
+  /** The typed-data message being signed. */
+  message: Record<string, unknown>;
+}
+/**
+ * The reusable serialized `@fhevm/sdk` decryption permit persisted inside a
+ * {@link Permission} — passed verbatim to `parseSignedDecryptionPermit`.
+ *
+ * Mirrors {@link SerializedPermitSchema}; kept in sync by a `.test-d.ts` guard.
+ */
+interface SerializedPermit {
+  /** Serialization format version. */
+  version: number;
+  /** The EIP-712 typed data that was signed. */
+  eip712: SerializedPermitEip712;
+  /** The signer's EIP-712 signature, hex-encoded. */
+  signature: Hex;
+  /** Address that produced the signature. */
+  signerAddress: ChecksummedAddress;
+}
+/**
+ * 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.
+ *
+ * Mirrors {@link PermissionSchema}; kept in sync by a `.test-d.ts` guard.
+ */
+interface Permission {
+  /** Public key of the transport key pair this permit is bound to, hex-encoded. */
+  keypairPublicKey: Hex;
+  /** Contract addresses this permit grants decrypt access to. */
+  contractAddresses: ChecksummedAddress[];
+  /** The signed serialized permit. */
+  serializedPermit: SerializedPermit;
+  /** Unix timestamp (seconds) when the permit becomes valid. */
+  startTimestamp: number;
+  /** Validity window length in days from {@link Permission.startTimestamp}. */
+  durationDays: number;
+}
+//#endregion
 //#region src/wrappers-registry.d.ts
 /**
  * Default wrappers registry addresses for known chains.
@@ -20501,6 +20322,7 @@ interface ListPairsOptions {
  */
 declare class WrappersRegistry {
   #private;
+  /** Read-only chain access used for registry contract reads. */
   readonly provider: GenericProvider;
   constructor(config: WrappersRegistryConfig);
   /**
@@ -20550,6 +20372,7 @@ declare class WrappersRegistry {
   listPairs(options: ListPairsOptions & {
     metadata: true;
   }): Promise<PaginatedResult<TokenWrapperPairWithMetadata>>;
+  /** Lists registered underlying/confidential token pairs; pass `{ metadata: true }` to include on-chain token metadata. */
   listPairs(options?: ListPairsOptions): Promise<PaginatedResult<TokenWrapperPair>>;
   /**
    * Look up the confidential token for a given plain ERC-20 address.
@@ -20655,8 +20478,11 @@ declare class WrappersRegistry {
  */
 declare class ZamaSDK {
   #private;
+  /** Read-only chain access used for all contract reads. */
   readonly provider: GenericProvider;
+  /** Wallet signer used for write operations, or `undefined` when the SDK is read-only. */
   readonly signer: GenericSigner | undefined;
+  /** Storage for cached permits and transport key pairs. */
   readonly storage: GenericStorage;
   /**
    * A {@link WrappersRegistry} instance auto-configured for the current chain.
@@ -20670,43 +20496,10 @@ declare class ZamaSDK {
   /** FHE decryption (user, delegated user, public). */
   readonly decryption: Decryption;
   constructor(config: ZamaConfig);
-  /**
-   * Subscribe to wallet account transitions.
-   *
-   * @param listener - Called on each transition with a {@link WalletAccountChange} carrying
-   *   `previous` and `next` wallet account snapshots; either may be `undefined` for
-   *   connect and disconnect transitions.
-   * @returns An unsubscribe function; calling it removes the listener.
-   *
-   * @internal
-   */
-  onWalletAccountChange(listener: WalletAccountListener): () => void;
-  /**
-   * The SDK-wide logger, exposed so contract abstractions ({@link Token},
-   * {@link WrappedToken}) can route their best-effort failures through the
-   * same sink. Silent by default.
-   *
-   * @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.
-   *
-   * Listener exceptions are caught and logged so that a misbehaving subscriber
-   * can never corrupt SDK operations.
-   *
-   * Application code should subscribe via the `onEvent` config option, never
-   * call this directly.
-   *
-   * @internal
    */
-  emitEvent(input: ZamaSDKEventInput, tokenAddress?: Address): void;
+  get relayer(): RelayerSDK;
   /**
    * Create a {@link WrappersRegistry} instance bound to this SDK's provider.
    * Inherits the registry addresses derived from the SDK's chain configs, so
@@ -20803,6 +20596,7 @@ declare class ZamaSDK {
 }
 //#endregion
 //#region src/utils/handles.d.ts
+/** All-zero encrypted-value sentinel — a 32-byte zero handle representing the cleartext value `0`. */
 declare const ZERO_ENCRYPTED_VALUE: "0x0000000000000000000000000000000000000000000000000000000000000000";
 /**
  * Check whether an encrypted value represents the zero value.
@@ -20813,8 +20607,14 @@ declare function isEncryptedValueZero(encryptedValue: string): boolean;
 /** In-memory credential store. Credentials are lost on page reload. */
 declare class MemoryStorage implements GenericStorage {
   #private;
+  /**
+   * Retrieve a value by key.
+   * @returns The stored value, or `null` if the key does not exist.
+   */
   get<T = unknown>(key: string): Promise<T | null>;
+  /** Store a value under the given key, overwriting any existing entry. */
   set<T = unknown>(key: string, value: T): Promise<void>;
+  /** Remove the entry for the given key (no-op if absent). */
   delete(key: string): Promise<void>;
 }
 /** Default singleton for application-wide use. */
@@ -20831,9 +20631,16 @@ declare const memoryStorage: MemoryStorage;
 declare class IndexedDBStorage implements GenericStorage {
   #private;
   constructor(dbName?: string, dbVersion?: number, storeName?: string);
+  /**
+   * Retrieve a value by key.
+   * @returns The stored value, or `null` if the key does not exist.
+   */
   get<T = unknown>(key: string): Promise<T | null>;
+  /** Store a value under the given key, overwriting any existing entry. */
   set<T = unknown>(key: string, value: T): Promise<void>;
+  /** Remove the entry for the given key (no-op if absent). */
   delete(key: string): Promise<void>;
+  /** Remove all stored entries. */
   clear(): Promise<void>;
 }
 /** Default singleton for application-wide use. */
@@ -20864,12 +20671,18 @@ declare const indexedDBStorage: IndexedDBStorage;
  * ```
  */
 declare class ChromeSessionStorage implements GenericStorage {
+  /**
+   * Retrieve a value by key.
+   * @returns The stored value, or `null` if the key does not exist.
+   */
   get<T = unknown>(key: string): Promise<T | null>;
+  /** Store a value under the given key, overwriting any existing entry. */
   set(key: string, value: unknown): Promise<void>;
+  /** Remove the entry for the given key (no-op if absent). */
   delete(key: string): Promise<void>;
 }
 /** Default singleton for application-wide use. */
 declare const chromeSessionStorage: ChromeSessionStorage;
 //#endregion
-export { DelegationNotFoundError as $, isOperatorContract as $t, SignerNotConfiguredError as A, delegateForUserDecryptionContract as At, ERC20ReadFailedError as B, supportsInterfaceContract as Bt, BatchDecryptItem as C, getConfidentialTokenAddressContract as Ct, TransactionRevertedError as D, getTokenPairsLengthContract as Dt, matchZamaError as E, getTokenPairsContract as Et, NotEntitledError as F, ERC1363_INTERFACE_ID as Ft, EncryptionFailedError as G, nameContract as Gt, InsufficientConfidentialBalanceError as H, approveContract as Ht, ConfigurationError as I, ERC7984_INTERFACE_ID as It, DelegationCooldownError as J, confidentialTotalSupplyContract as Jt, AclPausedError as K, symbolContract as Kt, RelayerRequestFailedError as L, ERC7984_WRAPPER_INTERFACE_ID as Lt, WalletAccountNotReadyError as M, isHandleDelegatedContract as Mt, WalletNotConnectedError as N, revokeDelegationContract as Nt, SigningFailedError as O, getTokenPairsSliceContract as Ot, RpcRateLimitError as P, transferAndCallContract as Pt, DelegationExpiryUnchangedError as Q, inferredTotalSupplyContract as Qt, BalanceCheckUnavailableError as R, isConfidentialTokenContract as Rt, Decryption as S, TokenWrapperPairWithMetadata as St, DelegatedDecryptOptions as T, getTokenPairContract as Tt, InsufficientERC20BalanceError as U, balanceOfContract as Ut, InsufficientAllowanceError as V, allowanceContract as Vt, DecryptionFailedError as W, decimalsContract as Wt, DelegationExpirationTooSoonError as X, confidentialTransferFromContract as Xt, DelegationDelegateEqualsContractError as Y, confidentialTransferContract as Yt, DelegationExpiredError as Z, finalizeUnwrapContract as Zt, BatchBalancesResult as _, zamaQueryKeys as _t, IndexedDBStorage as a, wrapContract as an, ChainMismatchError as at, Permits as b, PaginatedResult as bt, memoryStorage as c, resolveStorage as cn, isRetryable as ct, ZamaSDK as d, SerializedTransportKeyPair as dt, rateContract as en, DelegationNotPropagatedError as et, DefaultRegistryAddresses as f, StoredTransportKeyPair as ft, WrappedToken as g, SignerQueryContext as gt, WrappersRegistryConfig as h, decryptValuesQueryOptions as ht, chromeSessionStorage as i, unwrapFromBalanceContract as in, TransportKeyPairExpiredError as it, SignerRequiredError as j, getDelegationExpiryContract as jt, SigningRejectedError as k, isConfidentialTokenValidContract as kt, ZERO_ENCRYPTED_VALUE as l, createConfig as ln, retryAfterSeconds as lt, WrappersRegistry as m, EncryptedInput as mt, Hex$1 as n, underlyingContract as nn, InvalidTransportKeyPairError as nt, indexedDBStorage as o, ResolvedChainRelayer as on, ZamaError as ot, ListPairsOptions as p, DecryptResult as pt, DelegationContractIsSelfError as q, confidentialBalanceOfContract as qt, ChromeSessionStorage as r, unwrapContract as rn, NoCiphertextError as rt, MemoryStorage as s, resolveChainRelayers as sn, ZamaErrorCode as st, Address$1 as t, setOperatorContract as tn, DelegationSelfNotAllowedError as tt, isEncryptedValueZero as u, Permission as ut, BatchDecryptAsOptions as v, MutationFactoryOptions as vt, BatchDecryptResult as w, getTokenAddressContract as wt, Delegations as x, TokenWrapperPair as xt, Token as y, QueryFactoryOptions as yt, BalanceErrorDetails as z, isConfidentialWrapperContract as zt };
-//# sourceMappingURL=index-C4Hn6K9c.d.ts.map
+export { AclPausedError as $, confidentialTransferContract as $t, BatchDecryptResult as A, getTokenPairsContract as At, WalletNotConnectedError as B, ERC7984_INTERFACE_ID as Bt, BatchDecryptAsOptions as C, QueryFactoryOptions as Ct, DelegationStatus as D, getConfidentialTokenAddressContract as Dt, Delegations as E, TokenWrapperPairWithMetadata as Et, SigningFailedError as F, getDelegationExpiryContract as Ft, BalanceCheckUnavailableError as G, allowanceContract as Gt, NotEntitledError as H, isConfidentialTokenContract as Ht, SigningRejectedError as I, isHandleDelegatedContract as It, InsufficientAllowanceError as J, decimalsContract as Jt, BalanceErrorDetails as K, approveContract as Kt, SignerNotConfiguredError as L, revokeDelegationContract as Lt, ErrorForCode as M, getTokenPairsSliceContract as Mt, matchZamaError as N, isConfidentialTokenValidContract as Nt, Decryption as O, getTokenAddressContract as Ot, TransactionRevertedError as P, delegateForUserDecryptionContract as Pt, EncryptionFailedError as Q, confidentialTotalSupplyContract as Qt, SignerRequiredError as R, transferAndCallContract as Rt, BatchBalancesResult as S, MutationFactoryOptions as St, Permits as T, TokenWrapperPair as Tt, ConfigurationError as U, isConfidentialWrapperContract as Ut, RpcRateLimitError as V, ERC7984_WRAPPER_INTERFACE_ID as Vt, RelayerRequestFailedError as W, supportsInterfaceContract as Wt, InsufficientERC20BalanceError as X, symbolContract as Xt, InsufficientConfidentialBalanceError as Y, nameContract as Yt, DecryptionFailedError as Z, confidentialBalanceOfContract as Zt, SerializedPermit as _, DecryptResult as _t, IndexedDBStorage as a, setOperatorContract as an, DelegationExpiryUnchangedError as at, ChecksummedAddress as b, SignerQueryContext as bt, memoryStorage as c, unwrapFromBalanceContract as cn, DelegationSelfNotAllowedError as ct, ZamaSDK as d, TransportKeyPairExpiredError as dt, confidentialTransferFromContract as en, DelegationContractIsSelfError as et, DefaultRegistryAddresses as f, ChainMismatchError as ft, Permission as g, retryAfterSeconds as gt, WrappersRegistryConfig as h, isRetryable as ht, chromeSessionStorage as i, rateContract as in, DelegationExpiredError as it, DelegatedDecryptOptions as j, getTokenPairsLengthContract as jt, BatchDecryptItem as k, getTokenPairContract as kt, ZERO_ENCRYPTED_VALUE as l, wrapContract as ln, InvalidTransportKeyPairError as lt, WrappersRegistry as m, ZamaErrorCode as mt, Hex$1 as n, inferredTotalSupplyContract as nn, DelegationDelegateEqualsContractError as nt, indexedDBStorage as o, underlyingContract as on, DelegationNotFoundError as ot, ListPairsOptions as p, ZamaError as pt, ERC20ReadFailedError as q, balanceOfContract as qt, ChromeSessionStorage as r, isOperatorContract as rn, DelegationExpirationTooSoonError as rt, MemoryStorage as s, unwrapContract as sn, DelegationNotPropagatedError as st, Address$1 as t, finalizeUnwrapContract as tn, DelegationCooldownError as tt, isEncryptedValueZero as u, createConfig as un, NoCiphertextError as ut, SerializedPermitEip712 as v, EncryptedInput as vt, Token as w, PaginatedResult as wt, WrappedToken as x, zamaQueryKeys as xt, SerializedTransportKeyPair as y, decryptValuesQueryOptions as yt, WalletAccountNotReadyError as z, ERC1363_INTERFACE_ID as zt };
+//# sourceMappingURL=index-DLaQtvYu.d.ts.map