import { n as FheChain } from "../types-BgczXqW2.js";
import { a as hoodi, c as sepolia, i as hardhat, n as bscTestnet, o as ingenTestnet, r as chains, s as mainnet, t as anvil } from "../index-CYBH0nyo.js";
import { $ as CreateDelegatedEIP712ResponseData, At as WorkerRequest, C as BaseWorkerClient, Ct as RequestZKProofVerificationResponseData, Dt as UserDecryptRequest, Et as UserDecryptPayload, M as GenericStorage, Mt as WorkerResponse, Ot as UserDecryptResponseData, Q as CreateDelegatedEIP712Request, St as RequestZKProofVerificationRequest, Tt as UpdateCsrfRequest, X as BaseRequest, Z as CreateDelegatedEIP712Payload, _ as PublicParamsData, _t as InitPayload, at as DelegatedUserDecryptResponseData, bt as PublicDecryptRequest, c as DelegatedUserDecryptParams, ct as EncryptResponseData, d as EncryptParams, dt as GenerateKeypairResponseData, et as CreateEIP712Payload, f as EncryptResult, ft as GenericLogger, g as PublicDecryptResult, gt as GetPublicParamsResponseData, ht as GetPublicParamsRequest, it as DelegatedUserDecryptRequest, jt as WorkerRequestType, kt as WorkerEnv, l as EIP712TypedData, lt as ErrorResponse, m as FheEncryptionKey, mt as GetPublicKeyResponseData, n as RelayerSDK, nt as CreateEIP712ResponseData, o as TransportKeyPair, ot as EncryptPayload, p as EncryptedValue, pt as GetPublicKeyRequest, rt as DelegatedUserDecryptPayload, s as ClearValue, st as EncryptRequest, tt as CreateEIP712Request, ut as GenerateKeypairRequest, vt as InitRequest, wt as SuccessResponse, x as UserDecryptParams, xt as PublicDecryptResponseData, yt as PublicDecryptPayload } from "../relayer-cleartext-DkKKjfI6.js";
import { l as BaseRelayer, n as RelayerConfig } from "../types-BjDu-RZg.js";
import { t as cleartext } from "../cleartext-DMW5nK1M.js";
import { Address, Hex } from "viem";
import { Worker } from "node:worker_threads";
import { InputProofBytesType, KmsDelegatedUserDecryptEIP712Type, ZKProofLike } from "@zama-fhe/relayer-sdk/node";

//#region src/worker/worker.node-client.d.ts
interface NodeWorkerClientConfig {
  chains: FheChain[];
  /** SDK-wide logger for tracing worker request lifecycle. */
  logger: GenericLogger;
}
//#endregion
//#region src/worker/worker.node-pool.d.ts
interface NodeWorkerPoolConfig extends NodeWorkerClientConfig {
  poolSize?: number;
}
/**
 * Pool of Node.js worker threads for parallel FHE operations.
 *
 * **Default pool size:** `min(os.availableParallelism(), 4)`. Each worker loads
 * the full WASM module (~50–100 MB), so size the pool based on available memory.
 *
 * **Scheduling:** Least-connections — each request is dispatched to the worker
 * with the fewest in-flight operations.
 *
 * **When to override pool size:**
 * - High-throughput batch processing (e.g. bulk encryptions): increase to match CPU cores.
 * - Memory-constrained environments: decrease to 1–2 workers.
 *
 * **Lifecycle:**
 * 1. Initialize all workers: `await pool.initPool()`
 * 2. Use: `await pool.encrypt(...)`, `await pool.userDecrypt(...)`, etc.
 * 3. Shut down: `pool.terminate()`
 *
 * `initPool()` is idempotent — concurrent calls share the same initialization promise.
 * If any worker fails to initialize, all workers are terminated and the error is propagated.
 *
 * @internal Instantiated by the `node()` transport factory — not part of the public API.
 */
declare class NodeWorkerPool {
  #private;
  /**
   * @param config - Pool configuration. Set `poolSize` to override the default
   *   (`min(os.availableParallelism(), 4)`).
   */
  constructor(config: NodeWorkerPoolConfig);
  get poolSize(): number;
  initPool(): Promise<void>;
  terminate(): void;
  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/relayer/relayer-node.d.ts
interface RelayerNodeConfig {
  /** FHE chain configuration. */
  chain: FheChain;
  /** Worker thread pool — handles WASM operations off the main thread. */
  pool: NodeWorkerPool;
  /** SDK-wide logger for observing worker lifecycle and request timing. */
  logger: GenericLogger;
  /**
   * Persistent storage for caching FHE public key and params across sessions.
   * Defaults to `new MemoryStorage()` (in-process, lost on restart).
   * Pass a custom `GenericStorage` with redis for cross-restart persistence.
   */
  fheArtifactStorage?: GenericStorage;
  /** Cache TTL in seconds for FHE public material. Default: 86 400 (24 h). Set to 0 to revalidate on every operation. */
  fheArtifactCacheTTL?: number;
}
/**
 * RelayerNode — Node.js encryption/decryption layer.
 * The pool is injected at construction time; the relayer does not own its lifecycle.
 */
declare class RelayerNode extends BaseRelayer implements RelayerSDK, Disposable {
  #private;
  constructor(config: RelayerNodeConfig);
  protected get chain(): FheChain;
  protected init(): Promise<void>;
  /**
   * Terminate clears the artifact cache only.
   * The pool is externally owned — the relayer does not terminate it.
   */
  terminate(): void;
  /** Calls {@link terminate}. */
  [Symbol.dispose](): void;
  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>;
}
//#endregion
//#region src/node/config.d.ts
/**
 * Pool options for the `node()` transport factory.
 *
 * Logging is configured once, SDK-wide, via `createConfig({ logger })` — there
 * is deliberately no per-relayer logger option.
 */
interface NodePoolOptions {
  poolSize?: number;
  fheArtifactStorage?: GenericStorage;
  fheArtifactCacheTTL?: number;
}
/** Node transport — narrows worker type to `NodeWorkerPool`. */
interface NodeRelayerConfig extends RelayerConfig {
  readonly type: "node";
  readonly createWorker: (chains: FheChain[], logger: GenericLogger) => NodeWorkerPool;
  readonly createRelayer: (chain: FheChain, worker: NodeWorkerPool, logger: GenericLogger) => RelayerNode;
}
/**
 * Node.js transport — routes to RelayerNode (worker thread pool).
 *
 * @param options - Pool options (poolSize, logger, fheArtifactStorage, fheArtifactCacheTTL).
 *
 * @example
 * ```ts
 * relayers: {
 *   [sepolia.id]: node(),
 *   [mainnet.id]: node({ poolSize: 4 }),
 * }
 * ```
 */
declare function node(options?: NodePoolOptions): NodeRelayerConfig;
//#endregion
//#region src/storage/async-local-storage.d.ts
/**
 * {@link GenericStorage} backed by Node.js {@link AsyncLocalStorage}.
 *
 * Each async context (e.g. HTTP request) gets its own isolated `Map`,
 * so credentials from one request never leak into another.
 *
 * Call {@link run} to establish a context before using the SDK:
 *
 * ```ts
 * import { asyncLocalStorage } from "@zama-fhe/sdk/node";
 *
 * app.post("/api/transfer", (req, res) => {
 *   asyncLocalStorage.run(async () => {
 *     const sdk = new ZamaSDK({ relayer, signer, storage: asyncLocalStorage });
 *     // credentials are scoped to this request
 *   });
 * });
 * ```
 */
declare class AsyncLocalMapStorage implements GenericStorage {
  #private;
  /** Execute `fn` within an isolated storage context. */
  run<R>(fn: () => R | Promise<R>): R | Promise<R>;
  get<T = unknown>(key: string): Promise<T | null>;
  set<T = unknown>(key: string, value: T): Promise<void>;
  delete(key: string): Promise<void>;
}
/** Default singleton for application-wide use. */
declare const asyncLocalStorage: AsyncLocalMapStorage;
//#endregion
export { AsyncLocalMapStorage, type BaseRequest, BaseWorkerClient, type ClearValue, type CreateDelegatedEIP712Payload, type CreateDelegatedEIP712Request, type CreateDelegatedEIP712ResponseData, type CreateEIP712Payload, type CreateEIP712Request, type CreateEIP712ResponseData, type PublicDecryptResult as DecryptPublicValuesResult, type UserDecryptParams as DecryptValuesParams, type DelegatedUserDecryptParams as DelegatedDecryptValuesParams, type DelegatedUserDecryptPayload, type DelegatedUserDecryptRequest, type DelegatedUserDecryptResponseData, type EIP712TypedData, type EncryptParams, type EncryptPayload, type EncryptRequest, type EncryptResponseData, type EncryptResult, type ErrorResponse, type GenerateKeypairRequest, type GenerateKeypairResponseData, type GenericLogger, type GetPublicKeyRequest, type GetPublicKeyResponseData, type GetPublicParamsRequest, type GetPublicParamsResponseData, type InitPayload, type InitRequest, type NodePoolOptions, type NodeRelayerConfig, type NodeWorkerClientConfig, type NodeWorkerPoolConfig, type PublicDecryptRequest, type PublicDecryptResponseData, type RelayerConfig, type RelayerNodeConfig, type RelayerSDK, type RequestZKProofVerificationRequest, type RequestZKProofVerificationResponseData, type SuccessResponse, type UpdateCsrfRequest, type UserDecryptPayload, type UserDecryptRequest, type UserDecryptResponseData, type WorkerEnv, type WorkerRequest, type WorkerRequestType, type WorkerResponse, anvil, asyncLocalStorage, bscTestnet, chains, cleartext, hardhat, hoodi, ingenTestnet, mainnet, node, sepolia };
//# sourceMappingURL=index.d.ts.map