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

package/dist/esm/relayer-cleartext-CSeMlmGO.d.ts

@@ -1,844 +0,0 @@
-import { n as FheChain } from "./types-BgczXqW2.js";
-import { PrivateKeyAccount } from "viem/accounts";
-import { Abi, Address, ContractFunctionArgs, ContractFunctionName, ContractFunctionReturnType, Hex } from "viem";
-import { z } from "zod/mini";
-import * as SDK from "@zama-fhe/relayer-sdk/bundle";
-import { Bytes32Hex, ClearValueType, InputProofBytesType, KmsDelegatedUserDecryptEIP712Type, KmsUserDecryptEIP712Type, PublicDecryptResults, ZKProofLike } from "@zama-fhe/relayer-sdk/bundle";
-
-//#region src/utils/error.d.ts
-/**
- * A plain, structured-clone-safe snapshot of an error and its cause chain.
- *
- * The worker boundary (`postMessage`) strips prototypes, `code`/`status`, and —
- * critically — the `cause` chain, leaving only the message. Decryption errors
- * are classified on the **main thread** ({@link wrapDecryptError}), so the worker
- * only needs to faithfully hand the error across the boundary, not understand it.
- * `serializeError` is that mechanical, taxonomy-agnostic envelope: it copies the
- * scalar signal fields the classifier keys on and flattens the nested cause chain
- * into a single `cause` link. {@link deserializeError} rebuilds an `Error` whose
- * `.cause` chain mirrors the original, so the existing chain-walking detectors
- * work on it unchanged.
- */
-interface SerializedError {
-  name: string;
-  message: string;
-  /** e.g. JSON-RPC -32005, "RELAYER_FETCH_ERROR", ethers "CALL_EXCEPTION". */
-  code?: string | number;
-  /** viem-style HTTP status. */
-  status?: number;
-  /** relayer / node-fetch-style HTTP status. */
-  statusCode?: number;
-  /** Server-driven retry delay in **seconds** (numeric prop or parsed `Retry-After`). */
-  retryAfter?: number;
-  /**
-   * ethers surfaces an HTTP status only as a string on `info.responseStatus`
-   * (e.g. `"429 Too Many Requests"`), not as a numeric `status`. It lives on a
-   * nested `info` object the flattening would otherwise skip, so it is lifted
-   * onto the envelope and rebuilt onto `error.info.responseStatus`, letting the
-   * ethers rate-limit detector classify a worker-origin 429 exactly as it would
-   * the same error on the main thread.
-   */
-  responseStatus?: string;
-  cause?: SerializedError;
-}
-//#endregion
-//#region src/worker/worker.types.d.ts
-/**
- * Minimal four-level logger the SDK logs through.
- *
- * Supplied optionally by the consumer via `createConfig({ logger })` and
- * threaded SDK-wide; `console`, pino, winston, and OpenTelemetry's `DiagLogger`
- * satisfy it directly, so no adapter is needed. Levels: `error` (unexpected
- * internal failures only — never failures already surfaced via a rejection),
- * `warn` (recoverable/degraded conditions), `info` (reserved for coarse
- * lifecycle milestones; not currently emitted), `debug` (verbose diagnostics).
- */
-interface GenericLogger {
-  info: (message: string, data?: Record<string, unknown>) => void;
-  debug: (message: string, data?: Record<string, unknown>) => void;
-  warn: (message: string, data?: Record<string, unknown>) => void;
-  error: (message: string, data?: Record<string, unknown>) => void;
-}
-type WorkerEnv = "web" | "node";
-type WorkerRequestType = "INIT" | "UPDATE_CSRF" | "ENCRYPT" | "USER_DECRYPT" | "PUBLIC_DECRYPT" | "GENERATE_KEYPAIR" | "CREATE_EIP712" | "CREATE_DELEGATED_EIP712" | "DELEGATED_USER_DECRYPT" | "REQUEST_ZK_PROOF_VERIFICATION" | "GET_PUBLIC_KEY" | "GET_PUBLIC_PARAMS";
-interface BaseRequest {
-  id: string;
-  type: WorkerRequestType;
-}
-interface InitWebPayload {
-  env: "web";
-  cdnUrl: string;
-  chains: FheChain[];
-  csrfToken: string;
-  /** Expected SHA-384 hex digest for integrity verification. */
-  integrity?: string;
-  /** Number of WASM threads for parallel FHE operations. */
-  thread?: number;
-}
-interface InitNodePayload {
-  env: "node";
-  chains: FheChain[];
-}
-type InitPayload = InitWebPayload | InitNodePayload;
-interface InitRequest extends BaseRequest {
-  type: "INIT";
-  payload: InitPayload;
-}
-interface UpdateCsrfRequest extends BaseRequest {
-  type: "UPDATE_CSRF";
-  payload: {
-    csrfToken: string;
-  };
-}
-interface EncryptRequest extends BaseRequest {
-  type: "ENCRYPT";
-  payload: {
-    chainId: number;
-    values: EncryptInput[];
-    contractAddress: Address;
-    userAddress: Address;
-  };
-}
-interface UserDecryptRequest extends BaseRequest {
-  type: "USER_DECRYPT";
-  payload: {
-    chainId: number;
-    encryptedValues: EncryptedValue[];
-    contractAddress: Address;
-    signedContractAddresses: Address[];
-    privateKey: Hex;
-    publicKey: Hex;
-    signature: Hex;
-    signerAddress: Address;
-    startTimestamp: number;
-    durationDays: number;
-  };
-}
-interface PublicDecryptRequest extends BaseRequest {
-  type: "PUBLIC_DECRYPT";
-  payload: {
-    chainId: number;
-    encryptedValues: EncryptedValue[];
-  };
-}
-interface GenerateKeypairRequest extends BaseRequest {
-  type: "GENERATE_KEYPAIR";
-  payload: {
-    chainId: number;
-  };
-}
-interface CreateEIP712Request extends BaseRequest {
-  type: "CREATE_EIP712";
-  payload: {
-    chainId: number;
-    publicKey: Hex;
-    contractAddresses: Address[];
-    startTimestamp: number;
-    durationDays: number;
-  };
-}
-interface CreateDelegatedEIP712Request extends BaseRequest {
-  type: "CREATE_DELEGATED_EIP712";
-  payload: {
-    chainId: number;
-    publicKey: Hex;
-    contractAddresses: Address[];
-    delegatorAddress: Address;
-    startTimestamp: number;
-    durationDays: number;
-  };
-}
-interface DelegatedUserDecryptRequest extends BaseRequest {
-  type: "DELEGATED_USER_DECRYPT";
-  payload: {
-    chainId: number;
-    encryptedValues: EncryptedValue[];
-    contractAddress: Address;
-    signedContractAddresses: Address[];
-    privateKey: Hex;
-    publicKey: Hex;
-    signature: Hex;
-    delegatorAddress: Address;
-    delegateAddress: Address;
-    startTimestamp: number;
-    durationDays: number;
-  };
-}
-interface RequestZKProofVerificationRequest extends BaseRequest {
-  type: "REQUEST_ZK_PROOF_VERIFICATION";
-  payload: {
-    chainId: number;
-    zkProof: ZKProofLike;
-  };
-}
-interface GetPublicKeyRequest extends BaseRequest {
-  type: "GET_PUBLIC_KEY";
-  payload: {
-    chainId: number;
-  };
-}
-interface GetPublicParamsRequest extends BaseRequest {
-  type: "GET_PUBLIC_PARAMS";
-  payload: {
-    chainId: number;
-    bits: number;
-  };
-}
-type WorkerRequest = InitRequest | UpdateCsrfRequest | EncryptRequest | UserDecryptRequest | PublicDecryptRequest | GenerateKeypairRequest | CreateEIP712Request | CreateDelegatedEIP712Request | DelegatedUserDecryptRequest | RequestZKProofVerificationRequest | GetPublicKeyRequest | GetPublicParamsRequest;
-type EncryptPayload = EncryptRequest["payload"];
-type UserDecryptPayload = UserDecryptRequest["payload"];
-type PublicDecryptPayload = PublicDecryptRequest["payload"];
-type DelegatedUserDecryptPayload = DelegatedUserDecryptRequest["payload"];
-type CreateEIP712Payload = CreateEIP712Request["payload"];
-type CreateDelegatedEIP712Payload = CreateDelegatedEIP712Request["payload"];
-interface BaseResponse {
-  id: string;
-  type: WorkerRequestType;
-}
-interface SuccessResponse<T> extends BaseResponse {
-  success: true;
-  data: T;
-}
-/**
- * A failed worker response. The error and its cause chain are serialized into a
- * structured-clone-safe {@link SerializedError} (structured clone strips
- * prototypes/codes/causes across the boundary); the main thread rebuilds it
- * ({@link deserializeError}) and classifies it once in `wrapDecryptError`.
- */
-type ErrorResponse = BaseResponse & {
-  success: false;
-  error: string;
-  serialized?: SerializedError;
-};
-type WorkerResponse<T> = SuccessResponse<T> | ErrorResponse;
-type EncryptResponseData = InputProofBytesType;
-interface UserDecryptResponseData {
-  clearValues: Record<EncryptedValue, ClearValue>;
-}
-interface PublicDecryptResponseData {
-  clearValues: Readonly<Record<EncryptedValue, ClearValue>>;
-  abiEncodedClearValues: Hex;
-  decryptionProof: Hex;
-}
-interface GenerateKeypairResponseData {
-  publicKey: Hex;
-  privateKey: Hex;
-}
-type CreateEIP712ResponseData = KmsUserDecryptEIP712Type;
-type CreateDelegatedEIP712ResponseData = KmsDelegatedUserDecryptEIP712Type;
-interface DelegatedUserDecryptResponseData {
-  clearValues: Record<EncryptedValue, ClearValue>;
-}
-type RequestZKProofVerificationResponseData = InputProofBytesType;
-interface GetPublicKeyResponseData {
-  result: {
-    publicKeyId: string;
-    publicKey: Uint8Array;
-  } | null;
-}
-interface GetPublicParamsResponseData {
-  result: {
-    publicParams: Uint8Array;
-    publicParamsId: string;
-  } | null;
-}
-//#endregion
-//#region src/types/contract.d.ts
-/** ABI type accepted by contract call builders. Supports both typed and untyped ABIs. */
-type ContractAbi = Abi | readonly unknown[];
-/** Extract read-only function names (`pure` | `view`) from a contract ABI. */
-type ReadFunctionName<TAbi extends ContractAbi = ContractAbi> = ContractFunctionName<TAbi, "pure" | "view">;
-/** Extract write function names (`nonpayable` | `payable`) from a contract ABI. */
-type WriteFunctionName<TAbi extends ContractAbi = ContractAbi> = ContractFunctionName<TAbi, "nonpayable" | "payable">;
-/** Infer the argument tuple for a read-only contract function. */
-type ReadContractArgs<TAbi extends ContractAbi = ContractAbi, TFunctionName extends ReadFunctionName<TAbi> = ReadFunctionName<TAbi>> = ContractFunctionArgs<TAbi, "pure" | "view", TFunctionName>;
-/** Infer the argument tuple for a write contract function. */
-type WriteContractArgs<TAbi extends ContractAbi = ContractAbi, TFunctionName extends WriteFunctionName<TAbi> = WriteFunctionName<TAbi>> = ContractFunctionArgs<TAbi, "nonpayable" | "payable", TFunctionName>;
-/** Infer the return type for a read-only contract function. */
-type ReadContractReturnType<TAbi extends ContractAbi = ContractAbi, TFunctionName extends ReadFunctionName<TAbi> = ReadFunctionName<TAbi>, TArgs extends ReadContractArgs<TAbi, TFunctionName> = ReadContractArgs<TAbi, TFunctionName>> = ContractFunctionReturnType<TAbi, "pure" | "view", TFunctionName, TArgs>;
-/**
- * Typed read-contract configuration.
- * Matches the shape returned by read contract builders in `src/contracts/`.
- */
-interface ReadContractConfig<TAbi extends ContractAbi = ContractAbi, TFunctionName extends ReadFunctionName<TAbi> = ReadFunctionName<TAbi>, TArgs extends ReadContractArgs<TAbi, TFunctionName> = ReadContractArgs<TAbi, TFunctionName>> {
-  /** Target contract address. */
-  readonly address: Address;
-  /** ABI fragment for the function being called. */
-  readonly abi: TAbi;
-  /** Solidity function name. */
-  readonly functionName: TFunctionName;
-  /** Contract call arguments inferred from the ABI and function name. */
-  readonly args: TArgs;
-}
-/**
- * Typed write-contract configuration.
- * Matches the shape returned by write contract builders in `src/contracts/`.
- */
-interface WriteContractConfig<TAbi extends ContractAbi = ContractAbi, TFunctionName extends WriteFunctionName<TAbi> = WriteFunctionName<TAbi>, TArgs extends WriteContractArgs<TAbi, TFunctionName> = WriteContractArgs<TAbi, TFunctionName>> {
-  /** Target contract address. */
-  readonly address: Address;
-  /** ABI fragment for the function being called. */
-  readonly abi: TAbi;
-  /** Solidity function name. */
-  readonly functionName: TFunctionName;
-  /** Contract call arguments inferred from the ABI and function name. */
-  readonly args: TArgs;
-  /** Native value to send with the transaction (for payable functions). */
-  readonly value?: bigint;
-  /** Gas limit override. */
-  readonly gas?: bigint;
-}
-//#endregion
-//#region src/types/transaction.d.ts
-/** Framework-agnostic log shape compatible with any Ethereum provider. */
-interface RawLog {
-  /** Indexed event topics (topic[0] is the event signature hash). */
-  readonly topics: readonly Hex[];
-  /** ABI-encoded non-indexed event data. */
-  readonly data: Hex;
-}
-/** Framework-agnostic transaction receipt (only the fields the SDK needs). */
-interface TransactionReceipt {
-  /** Event logs emitted during the transaction. */
-  readonly logs: readonly RawLog[];
-}
-/** Result of a write operation: the tx hash and its mined receipt. */
-interface TransactionResult {
-  /** The transaction hash. */
-  txHash: Hex;
-  /** The mined transaction receipt. */
-  receipt: TransactionReceipt;
-}
-//#endregion
-//#region src/types/signer.d.ts
-/** Snapshot of the connected wallet account at a point in time. */
-interface WalletAccount {
-  address: Address;
-  chainId: number;
-}
-/** A wallet account transition emitted by signer adapters. */
-interface WalletAccountChange {
-  previous?: WalletAccount;
-  next?: WalletAccount;
-}
-/** Listener for wallet account transitions. */
-type WalletAccountListener = (change: WalletAccountChange) => void;
-/**
- * Synchronous observable store for wallet account readiness.
- *
- * Direct subscriptions observe raw signer adapter transitions. For SDK-
- * coordinated cleanup and React query invalidation, subscribe through
- * `ZamaSDK.onWalletAccountChange` so credential/cache cleanup runs first.
- */
-interface WalletAccountStore {
-  /** Synchronous, non-prompting snapshot of the currently connected wallet account. */
-  getSnapshot(): WalletAccount | undefined;
-  /**
-   * Whether the store has received at least one snapshot. Adapters whose
-   * initial account is only available asynchronously start unready; callers
-   * can distinguish "still loading" from "wallet not connected".
-   */
-  isReady(): boolean;
-  /**
-   * Subscribe to wallet account transitions (connect, disconnect, account
-   * change, chain change). Returns an unsubscribe function.
-   *
-   * If a wallet account is already known when `subscribe` is called, the
-   * listener MUST be invoked synchronously with
-   * `{ previous: undefined, next: <current> }`. The SDK relies on this to
-   * warm credentials for already-connected signers; custom stores that skip
-   * this initial emit will silently break credential pre-warming.
-   */
-  subscribe(onWalletAccountChange: WalletAccountListener): () => void;
-}
-/**
- * Framework-agnostic signer interface — wallet authority only.
- *
- * Public chain reads have moved to {@link GenericProvider}. A signer is only
- * required for operations that involve a user-controlled wallet
- * (`requireWalletAccount`, `signTypedData`, `writeContract`).
- */
-interface GenericSigner {
-  /** Observable wallet account readiness state. */
-  readonly walletAccount: WalletAccountStore;
-  /**
-   * Return the currently connected wallet account or throw
-   * {@link WalletNotConnectedError}. Must not initiate wallet connection.
-   */
-  requireWalletAccount(operation: string): WalletAccount;
-  /**
-   * Optional non-prompting account discovery hook for adapters whose initial
-   * account snapshot is only available asynchronously.
-   */
-  refreshWalletAccount?(): Promise<WalletAccount | undefined>;
-  /** Sign EIP-712 typed data (used for decrypt authorization). */
-  signTypedData(typedData: EIP712TypedData): Promise<Hex>;
-  /** Send a write transaction and return the tx hash. */
-  writeContract<const TAbi extends ContractAbi, TFunctionName extends WriteFunctionName<TAbi>, const TArgs extends WriteContractArgs<TAbi, TFunctionName>>(config: WriteContractConfig<TAbi, TFunctionName, TArgs>): Promise<Hex>;
-  /** Release adapter-owned wallet watchers or provider event listeners. */
-  dispose?(): void;
-}
-//#endregion
-//#region src/types/provider.d.ts
-/**
- * Framework-agnostic read-only provider interface.
- *
- * Represents the minimal set of capabilities needed to perform public chain
- * reads: querying state via `eth_call`, checking chain identity, awaiting
- * transaction receipts, and fetching block timestamps.
- *
- * Any caller with only an RPC endpoint (server indexer, SSR, dApp pre-connect)
- * can drive the SDK via a {@link GenericProvider} implementation, without
- * instantiating a wallet-shaped object. Use {@link ViemProvider},
- * {@link EthersProvider}, or {@link WagmiProvider}; or implement the
- * interface directly.
- */
-interface GenericProvider {
-  /** Return the chain ID of the connected network. */
-  getChainId(): Promise<number>;
-  /** Execute a read-only call and return the decoded result. */
-  readContract<const TAbi extends ContractAbi, TFunctionName extends ReadFunctionName<TAbi>, const TArgs extends ReadContractArgs<TAbi, TFunctionName>>(config: ReadContractConfig<TAbi, TFunctionName, TArgs>): Promise<ReadContractReturnType<TAbi, TFunctionName, TArgs>>;
-  /** Wait for a transaction to be mined and return its receipt. */
-  waitForTransactionReceipt(hash: Hex): Promise<TransactionReceipt>;
-  /** Return the latest block timestamp in seconds. */
-  getBlockTimestamp(): Promise<bigint>;
-}
-//#endregion
-//#region src/types/storage.d.ts
-/**
- * Pluggable key-value store for persisting FHE credentials.
- *
- * The SDK stores objects directly (not JSON strings). Implementations must
- * preserve value types through round-trips — e.g. `IndexedDBStorage` uses
- * structured clone, `MemoryStorage` stores values as-is.
- */
-interface GenericStorage {
-  /** Retrieve a value by key. Returns `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>;
-}
-//#endregion
-//#region src/types/callbacks.d.ts
-/** Progress callbacks for multi-step unshield operations. */
-interface UnshieldCallbacks {
-  /** Fired after the unwrap transaction is submitted. */
-  onUnwrapSubmitted?: (txHash: Hex) => void;
-  /** Fired when the finalization step begins (receipt parsed, about to finalize). */
-  onFinalizing?: () => void;
-  /** Fired after the finalize transaction is submitted. */
-  onFinalizeSubmitted?: (txHash: Hex) => void;
-}
-/** Progress callbacks for multi-step shield operations. */
-interface ShieldCallbacks {
-  /** Fired after the ERC-20 approval transaction is submitted (skipped when `approvalStrategy: "skip"`). */
-  onApprovalSubmitted?: (txHash: Hex) => void;
-  /** Fired after the shield (wrap) transaction is submitted. */
-  onShieldSubmitted?: (txHash: Hex) => void;
-}
-/** Progress callbacks for multi-step confidential transfer operations. */
-interface TransferCallbacks {
-  /** Fired after FHE encryption of the transfer amount completes. */
-  onEncryptComplete?: () => void;
-  /** Fired after the transfer transaction is submitted. */
-  onTransferSubmitted?: (txHash: Hex) => void;
-}
-//#endregion
-//#region src/types/token.d.ts
-/** Options for {@link ConfidentialToken.confidentialTransfer}. */
-interface TransferOptions extends TransferCallbacks {
-  /** Skip confidential balance validation (e.g. for smart wallets). Default: `false`. */
-  skipBalanceCheck?: boolean;
-}
-/**
- * User-facing approval strategy.
- *
- * - `"exact"` (default): approve exactly `amount`.
- * - `"max"`: approve unlimited.
- * - `"skip"`: assume a pre-existing approval; skip the approve step.
- */
-type ApprovalStrategy = "max" | "exact" | "skip";
-/**
- * The resolved shielding execution path — what actually ran on-chain.
- * Reported on {@link ShieldSubmittedEvent}; on a failure, the path is
- * encoded in {@link TransactionErrorEvent.operation} as
- * `"shield:transferAndCall"` or `"shield:approveAndWrap"`. Decided
- * automatically by ERC-165 introspection on the underlying ERC-20.
- *
- * - `"transferAndCall"`: single tx via ERC-1363 (no approval).
- * - `"approveAndWrap"`: legacy two-tx path (`approve` then `wrap`).
- */
-type ShieldPath = "transferAndCall" | "approveAndWrap";
-/** Options for {@link WrappedToken.shield}. */
-interface ShieldOptions extends ShieldCallbacks {
-  /** See {@link ApprovalStrategy}. Default: `"exact"`. Ignored when the underlying supports ERC-1363 (single-tx path requires no approval). */
-  approvalStrategy?: ApprovalStrategy;
-  /** Recipient address for the shielded tokens. Defaults to the connected wallet. */
-  to?: Address;
-}
-/** Options for {@link WrappedToken.unshield}. */
-interface UnshieldOptions extends UnshieldCallbacks {
-  /** Skip confidential balance validation (e.g. for smart wallets). Default: `false`. */
-  skipBalanceCheck?: boolean;
-}
-//#endregion
-//#region src/worker/worker.base-client.d.ts
-/**
- * Timeout / recovery knobs shared by every worker client (node + web), so the
- * base class can read them generically off `config`.
- */
-interface WorkerClientTimeoutConfig {
-  /** Per-operation timeout in **seconds**. Defaults to 30. */
-  operationTimeout?: number;
-  /** WASM-init timeout in **seconds**. Defaults to 60. */
-  initTimeout?: number;
-  /**
-   * Recycle (terminate + lazily re-init) the worker after an operation timeout,
-   * so a hung thread can't keep serving requests. Defaults to `true`.
-   */
-  recycleWorkerOnTimeout?: boolean;
-  /** Diagnostic label surfaced on {@link WorkerTimeoutError} (e.g. `node-worker-2`). */
-  workerLabel?: string;
-}
-/**
- * Abstract base class for worker clients (browser Web Worker and Node.js worker_threads).
- * Encapsulates all shared logic: pending request tracking, timeouts, init dedup, domain methods.
- * Subclasses implement the abstract hooks for platform-specific worker creation and messaging.
- */
-declare abstract class BaseWorkerClient<TWorker, TConfig extends WorkerClientTimeoutConfig> {
-  #private;
-  protected readonly config: TConfig;
-  protected readonly logger: GenericLogger;
-  constructor(config: TConfig, logger: GenericLogger);
-  /** Create the platform-specific worker instance. */
-  protected abstract createWorker(): TWorker;
-  /** Wire message/error/messageerror events on the worker. */
-  protected abstract wireEvents(worker: TWorker): void;
-  /** Post a message to the worker. */
-  protected abstract postMessage(worker: TWorker, request: WorkerRequest): void;
-  /** Terminate the platform-specific worker. */
-  protected abstract terminateWorker(worker: TWorker): void;
-  /** Generate a unique request ID. */
-  protected abstract generateRequestId(): string;
-  /** Return the init request type and payload. */
-  protected abstract getInitPayload(): {
-    type: WorkerRequestType;
-    payload: WorkerRequest["payload"];
-  };
-  /** Subclasses set "web" or "node" — stamps the env discriminant on INIT payloads. */
-  protected abstract readonly env: WorkerEnv;
-  /** Optional hook called after worker init succeeds (e.g. for node worker.unref()). */
-  protected onWorkerReady?(_worker: TWorker): void;
-  initWorker(): Promise<TWorker>;
-  terminate(): void;
-  protected handleResponse(response: WorkerResponse<unknown>): void;
-  protected handleWorkerError(message: string): void;
-  protected handleWorkerMessageError(): void;
-  protected sendRequestTo<T>(worker: TWorker, type: WorkerRequestType, payload: WorkerRequest["payload"], timeoutMs?: number): Promise<T>;
-  protected sendRequest<T>(type: WorkerRequestType, payload: WorkerRequest["payload"], timeoutMs?: number): Promise<T>;
-  generateKeypair(params: GenerateKeypairRequest["payload"]): Promise<GenerateKeypairResponseData>;
-  createEIP712(params: CreateEIP712Payload): Promise<CreateEIP712ResponseData>;
-  encrypt(params: EncryptPayload): Promise<EncryptResponseData>;
-  userDecrypt(params: UserDecryptPayload): Promise<UserDecryptResponseData>;
-  publicDecrypt(params: PublicDecryptPayload): Promise<PublicDecryptResponseData>;
-  createDelegatedUserDecryptEIP712(params: CreateDelegatedEIP712Payload): Promise<CreateDelegatedEIP712ResponseData>;
-  delegatedUserDecrypt(params: DelegatedUserDecryptPayload): Promise<DelegatedUserDecryptResponseData>;
-  requestZKProofVerification(params: RequestZKProofVerificationRequest["payload"]): Promise<RequestZKProofVerificationResponseData>;
-  getPublicKey(params: GetPublicKeyRequest["payload"]): Promise<GetPublicKeyResponseData>;
-  getPublicParams(params: GetPublicParamsRequest["payload"]): Promise<GetPublicParamsResponseData>;
-}
-//#endregion
-//#region src/worker/worker.client.d.ts
-/** Configuration for the worker client */
-interface WorkerClientConfig extends WorkerClientTimeoutConfig {
-  cdnUrl: string;
-  chains: FheChain[];
-  csrfToken: string;
-  /** Expected SHA-384 hex digest of the CDN bundle for integrity verification. */
-  integrity?: string;
-  /** SDK-wide logger for tracing worker request lifecycle. */
-  logger: GenericLogger;
-  /** Number of WASM threads for parallel FHE operations (passed to `initSDK({ thread })`). */
-  thread?: number;
-}
-/**
- * Client for communicating with the RelayerSDK Web Worker.
- * Provides a promise-based API for FHE operations.
- */
-declare class RelayerWorkerClient extends BaseWorkerClient<Worker, WorkerClientConfig> {
-  protected readonly env: WorkerEnv;
-  constructor(config: WorkerClientConfig);
-  protected createWorker(): Worker;
-  protected wireEvents(worker: Worker): void;
-  protected postMessage(worker: Worker, request: WorkerRequest): void;
-  protected terminateWorker(worker: Worker): void;
-  protected generateRequestId(): string;
-  protected getInitPayload(): {
-    type: WorkerRequestType;
-    payload: WorkerRequest["payload"];
-  };
-  /**
-   * Update the CSRF token in the worker.
-   * Call this before making authenticated requests to ensure the token is fresh.
-   */
-  updateCsrf(csrfToken: string): Promise<void>;
-}
-//#endregion
-//#region src/relayer/relayer-sdk.types.d.ts
-/** Network configuration for the Relayer SDK */
-type NetworkType = "hardhat" | "sepolia" | "mainnet";
-/** Security options for RelayerWeb. */
-interface RelayerWebSecurityConfig {
-  /** Resolve the current CSRF token. Called before each authenticated network request. */
-  getCsrfToken?: () => string;
-  /** Verify SHA-384 integrity of the CDN bundle. Defaults to `true`. Set to `false` only in test environments with mocked SDK scripts. */
-  integrityCheck?: boolean;
-}
-/** Configuration for RelayerWeb (browser backend) initialization. */
-interface RelayerWebConfig {
-  /** FHE chain configuration. */
-  chain: FheChain;
-  /** Worker client — handles WASM operations off the main thread. */
-  worker: RelayerWorkerClient;
-  /** Security options (CSRF, CDN integrity). */
-  security?: RelayerWebSecurityConfig;
-  /** SDK-wide logger for observing worker lifecycle and request timing. */
-  logger: GenericLogger;
-  /**
-   * Number of WASM threads for parallel FHE operations inside the Web Worker.
-   * Uses `wasm-bindgen-rayon` under the hood via `SharedArrayBuffer`.
-   *
-   * **Requirements:** The page must be served with COOP/COEP headers:
-   * - `Cross-Origin-Opener-Policy: same-origin`
-   * - `Cross-Origin-Embedder-Policy: require-corp`
-   *
-   * 4–8 threads is the practical sweet spot; beyond that, diminishing returns
-   * and higher memory usage on low-end devices.
-   *
-   * When omitted, the relayer SDK uses its default (single-threaded).
-   */
-  threads?: number;
-  /**
-   * Persistent storage for caching FHE public key and params across sessions.
-   *
-   * Defaults to `new IndexedDBStorage("FheArtifactCache", 1, "artifacts")`.
-   * Pass a custom `IndexedDBStorage` instance to configure the database name,
-   * version, or store name. FHE public params can be several MB — avoid
-   * `localStorage`-backed storage which caps at ~5 MB.
-   *
-   * **Not to be confused with `ZamaProvider.storage`** which stores credentials.
-   */
-  fheArtifactStorage?: GenericStorage;
-  /** Cache TTL in seconds for FHE public material. Default: 86 400 (24 h). Set to 0 to revalidate on every operation. Ignored when storage is not set. */
-  fheArtifactCacheTTL?: number;
-}
-/** Canonical SDK type for an encrypted value — a `bytes32` ciphertext reference. Alias for {@link Bytes32Hex}. */
-type EncryptedValue = Bytes32Hex;
-/** Result from encryption — contract-ready hex encrypted values and input proof. */
-type EncryptResult = {
-  encryptedValues: EncryptedValue[];
-  inputProof: Hex;
-};
-/** Canonical SDK type for a decrypted clear-text value (`bigint | boolean | string`). */
-type ClearValue = ClearValueType;
-/** A single value to encrypt with its FHE type. */
-type EncryptInput = {
-  value: boolean | bigint;
-  type: "ebool";
-} | {
-  value: bigint;
-  type: Exclude<SDK.FheTypeName, "ebool" | "eaddress">;
-} | {
-  value: Address;
-  type: "eaddress";
-};
-/** Parameters for encryption */
-interface EncryptParams {
-  /** Typed inputs for encryption. Each value must specify its FHE type. */
-  values: EncryptInput[];
-  contractAddress: Address;
-  userAddress: Address;
-}
-/** Parameters for user decryption */
-interface UserDecryptParams {
-  encryptedValues: EncryptedValue[];
-  contractAddress: Address;
-  signedContractAddresses: Address[];
-  privateKey: Hex;
-  publicKey: Hex;
-  signature: Hex;
-  signerAddress: Address;
-  startTimestamp: number;
-  durationDays: number;
-}
-/** Result from public decryption. Alias for {@link PublicDecryptResults}. */
-type PublicDecryptResult = PublicDecryptResults;
-/**
- * EIP712 typed data structure for user or delegated user decrypt requests.
- * Union of the relayer-sdk's two user-decrypt EIP712 shapes.
- */
-type EIP712TypedData = KmsUserDecryptEIP712Type | KmsDelegatedUserDecryptEIP712Type;
-/** FHE encryption key — the network's TFHE public key used to encrypt inputs for confidential contracts. */
-interface FheEncryptionKey {
-  publicKeyId: string;
-  publicKey: Uint8Array;
-}
-/**
- * TFHE public parameters
- */
-type PublicParamsData = SDK.PublicParams<Uint8Array>[keyof SDK.PublicParams<Uint8Array>];
-/** Parameters for delegated user decryption */
-interface DelegatedUserDecryptParams {
-  encryptedValues: EncryptedValue[];
-  contractAddress: Address;
-  signedContractAddresses: Address[];
-  privateKey: Hex;
-  publicKey: Hex;
-  signature: Hex;
-  delegatorAddress: Address;
-  delegateAddress: Address;
-  startTimestamp: number;
-  durationDays: number;
-}
-/** SDK status */
-type RelayerSDKStatus = "idle" | "initializing" | "ready" | "error";
-//#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}`>;
-  signerAddress: z.ZodMiniPipe<z.ZodMiniCustom<`0x${string}`, `0x${string}`>, z.ZodMiniTransform<ChecksummedAddress, `0x${string}`>>;
-  delegatorAddress: z.ZodMiniPipe<z.ZodMiniCustom<`0x${string}`, `0x${string}`>, z.ZodMiniTransform<ChecksummedAddress, `0x${string}`>>;
-  chainId: z.ZodMiniNumberFormat;
-  signedContractAddresses: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniCustom<`0x${string}`, `0x${string}`>, z.ZodMiniTransform<ChecksummedAddress, `0x${string}`>>>;
-  signature: z.ZodMiniCustom<`0x${string}`, `0x${string}`>;
-  startTimestamp: z.ZodMiniNumberFormat;
-  durationDays: z.ZodMiniNumberFormat;
-}, z.core.$strip>;
-//#endregion
-//#region src/credentials/types.d.ts
-/** In-memory transport key pair (ML-KEM public + private key, plaintext private half). */
-interface TransportKeyPair {
-  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.
- */
-type Permission = z.infer<typeof PermissionSchema>;
-/** Resolved transport key pair entry with permits for a decrypt operation. */
-interface StoredTransportKeyPairWithPermits {
-  readonly keypair: StoredTransportKeyPair;
-  readonly permits: readonly Permission[];
-}
-//#endregion
-//#region src/relayer/relayer-sdk.d.ts
-/**
- * Core FHE cryptographic operations — the 10 methods that perform
- * encryption, decryption, key generation, and proof verification.
- */
-interface FheOperations {
-  /** Generate a transport key pair (ML-KEM public + private key) used for user-decryption. */
-  generateTransportKeyPair(): Promise<TransportKeyPair>;
-  /**
-   * Create EIP-712 typed data for signing an FHE decrypt credential.
-   *
-   * Low-level credential builder. Prefer the high-level
-   * `sdk.decryption.decryptValues` ({@link Decryption.decryptValues}), which
-   * assembles and caches this credential for you.
-   */
-  createEIP712(publicKey: Hex, contractAddresses: Address[], startTimestamp: number, durationDays?: number): Promise<EIP712TypedData>;
-  /** Encrypt plaintext values into FHE ciphertexts. */
-  encrypt(params: EncryptParams): Promise<EncryptResult>;
-  /**
-   * Decrypt FHE encrypted values using the user's own credentials.
-   *
-   * Low-level: the caller assembles the credential bundle (transport key pair,
-   * EIP-712 permit) in {@link UserDecryptParams}. Prefer the high-level
-   * `sdk.decryption.decryptValues` ({@link Decryption.decryptValues}), which
-   * manages credentials, caching, and error wrapping.
-   */
-  userDecrypt(params: UserDecryptParams): Promise<Readonly<Record<EncryptedValue, ClearValue>>>;
-  /**
-   * Decrypt encrypted values using the network public key (no credential needed).
-   *
-   * Low-level. Prefer the high-level `sdk.decryption.decryptPublicValues`
-   * ({@link Decryption.decryptPublicValues}).
-   */
-  publicDecrypt(encryptedValues: EncryptedValue[]): Promise<PublicDecryptResult>;
-  /**
-   * Create EIP-712 typed data for a delegated user decrypt credential.
-   *
-   * Low-level credential builder. Prefer the high-level
-   * `sdk.decryption.delegatedDecryptValues` ({@link Decryption.delegatedDecryptValues}),
-   * which assembles and caches this credential for you.
-   */
-  createDelegatedUserDecryptEIP712(publicKey: Hex, contractAddresses: Address[], delegatorAddress: Address, startTimestamp: number, durationDays?: number): Promise<KmsDelegatedUserDecryptEIP712Type>;
-  /**
-   * Decrypt FHE encrypted values using delegated user credentials.
-   *
-   * Low-level: the caller assembles the delegated credential bundle in
-   * {@link DelegatedUserDecryptParams}. Prefer the high-level
-   * `sdk.decryption.delegatedDecryptValues` ({@link Decryption.delegatedDecryptValues}).
-   */
-  delegatedUserDecrypt(params: DelegatedUserDecryptParams): Promise<Readonly<Record<EncryptedValue, ClearValue>>>;
-  /** Submit a ZK proof for on-chain verification. */
-  requestZKProofVerification(zkProof: ZKProofLike): Promise<InputProofBytesType>;
-  /** Fetch the network's FHE encryption key. Returns `null` if not available. */
-  fetchFheEncryptionKeyBytes(): Promise<FheEncryptionKey | null>;
-  /** Fetch FHE public parameters for a given bit size. Returns `null` if not available. */
-  getPublicParams(bits: number): Promise<PublicParamsData | null>;
-}
-/**
- * Interface for FHE relayer operations.
- * Extends `FheOperations` with lifecycle and chain-specific methods.
- * Implemented by `RelayerWeb` (browser, via Web Worker + WASM) and `RelayerNode` (Node.js, direct).
- */
-interface RelayerSDK extends FheOperations {
-  /** Return the ACL contract address for the current chain. */
-  getAclAddress(): Promise<Address>;
-  /** Terminate the relayer backend and release resources. */
-  terminate(): void;
-}
-//#endregion
-//#region src/relayer/cleartext/relayer-cleartext.d.ts
-declare class RelayerCleartext implements RelayerSDK, Disposable {
-  #private;
-  readonly kmsSigner: PrivateKeyAccount;
-  readonly inputSigner: PrivateKeyAccount;
-  constructor(config: FheChain);
-  generateTransportKeyPair(): Promise<TransportKeyPair>;
-  createEIP712(publicKey: Hex, contractAddresses: Address[], startTimestamp: number, durationDays?: number): Promise<EIP712TypedData>;
-  encrypt(params: EncryptParams): Promise<EncryptResult>;
-  userDecrypt(params: UserDecryptParams): Promise<Readonly<Record<EncryptedValue, ClearValue>>>;
-  publicDecrypt(encryptedValues: EncryptedValue[]): Promise<PublicDecryptResult>;
-  createDelegatedUserDecryptEIP712(publicKey: Hex, contractAddresses: Address[], delegatorAddress: Address, startTimestamp: number, durationDays?: number): Promise<KmsDelegatedUserDecryptEIP712Type>;
-  delegatedUserDecrypt(params: DelegatedUserDecryptParams): Promise<Readonly<Record<EncryptedValue, ClearValue>>>;
-  requestZKProofVerification(_zkProof: ZKProofLike): Promise<InputProofBytesType>;
-  fetchFheEncryptionKeyBytes(): Promise<FheEncryptionKey | null>;
-  getPublicParams(_bits: number): Promise<PublicParamsData | null>;
-  getAclAddress(): Promise<Address>;
-  terminate(): void;
-  /** Calls {@link terminate} (no-op in cleartext mode). */
-  [Symbol.dispose](): void;
-}
-//#endregion
-export { CreateDelegatedEIP712Request as $, ShieldCallbacks as A, WorkerEnv as At, RawLog as B, BaseWorkerClient as C, RequestZKProofVerificationRequest as Ct, ShieldPath as D, UserDecryptPayload as Dt, ShieldOptions as E, UpdateCsrfRequest as Et, GenericSigner as F, ReadContractConfig as G, TransactionResult as H, WalletAccount as I, WriteContractArgs as J, ReadContractReturnType as K, WalletAccountChange as L, UnshieldCallbacks as M, WorkerRequestType as Mt, GenericStorage as N, WorkerResponse as Nt, TransferOptions as O, UserDecryptRequest as Ot, GenericProvider as P, SerializedError as Pt, CreateDelegatedEIP712Payload as Q, WalletAccountListener as R, RelayerWorkerClient as S, PublicDecryptResponseData as St, ApprovalStrategy as T, SuccessResponse as Tt, ContractAbi as U, TransactionReceipt as V, ReadContractArgs as W, WriteFunctionName as X, WriteContractConfig as Y, BaseRequest as Z, PublicParamsData as _, GetPublicParamsResponseData as _t, StoredTransportKeyPairWithPermits as a, DelegatedUserDecryptRequest as at, RelayerWebSecurityConfig as b, PublicDecryptPayload as bt, DelegatedUserDecryptParams as c, EncryptRequest as ct, EncryptParams as d, GenerateKeypairRequest as dt, CreateDelegatedEIP712ResponseData as et, EncryptResult as f, GenerateKeypairResponseData as ft, PublicDecryptResult as g, GetPublicParamsRequest as gt, NetworkType as h, GetPublicKeyResponseData as ht, StoredTransportKeyPair as i, DelegatedUserDecryptPayload as it, TransferCallbacks as j, WorkerRequest as jt, UnshieldOptions as k, UserDecryptResponseData as kt, EIP712TypedData as l, EncryptResponseData as lt, FheEncryptionKey as m, GetPublicKeyRequest as mt, RelayerSDK as n, CreateEIP712Request as nt, TransportKeyPair as o, DelegatedUserDecryptResponseData as ot, EncryptedValue as p, GenericLogger as pt, ReadFunctionName as q, Permission as r, CreateEIP712ResponseData as rt, ClearValue as s, EncryptPayload as st, RelayerCleartext as t, CreateEIP712Payload as tt, EncryptInput as u, ErrorResponse as ut, RelayerSDKStatus as v, InitPayload as vt, WorkerClientTimeoutConfig as w, RequestZKProofVerificationResponseData as wt, UserDecryptParams as x, PublicDecryptRequest as xt, RelayerWebConfig as y, InitRequest as yt, WalletAccountStore as z };
-//# sourceMappingURL=relayer-cleartext-CSeMlmGO.d.ts.map