@btc-vision/bitcoin 6.5.6 → 7.0.0-alpha.0

package/browser/workers/index.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Worker-based parallel signing module.
+ *
+ * Provides secure parallel signature computation using worker threads.
+ * Works in both Node.js (worker_threads) and browsers (Web Workers).
+ *
+ * @example
+ * ```typescript
+ * import { WorkerSigningPool, SignatureType } from '@btc-vision/bitcoin/workers';
+ *
+ * // Get singleton pool
+ * const pool = WorkerSigningPool.getInstance({ workerCount: 4 });
+ *
+ * // Keep workers alive for multiple signing operations
+ * pool.preserveWorkers();
+ *
+ * // Prepare signing tasks (one per input)
+ * const tasks = [
+ *     {
+ *         taskId: 'input-0',
+ *         inputIndex: 0,
+ *         hash: hash0,
+ *         signatureType: SignatureType.ECDSA,
+ *         sighashType: 0x01,
+ *     },
+ *     {
+ *         taskId: 'input-1',
+ *         inputIndex: 1,
+ *         hash: hash1,
+ *         signatureType: SignatureType.Schnorr,
+ *         sighashType: 0x00,
+ *     },
+ * ];
+ *
+ * // Sign ALL inputs in parallel
+ * const result = await pool.signBatch(tasks, keyPair);
+ *
+ * if (result.success) {
+ *     console.log(`Signed ${result.signatures.size} inputs in ${result.durationMs}ms`);
+ * }
+ *
+ * // Cleanup when done (optional)
+ * await pool.shutdown();
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { SignatureType, type SigningTaskMessage, type BatchSigningMessage, type BatchSigningTask, type BatchSigningResultMessage, type BatchSigningTaskResult, type BatchSigningTaskError, type WorkerInitMessage, type WorkerShutdownMessage, type WorkerMessage, type SigningResultMessage, type SigningErrorMessage, type WorkerReadyMessage, type WorkerShutdownAckMessage, type WorkerResponse, isSigningError, isSigningResult, isBatchResult, isWorkerReady, type WorkerEccLib, type WorkerPoolConfig, type SigningTask, type ParallelSignerKeyPair, type ParallelSigningResult, WorkerState, type PooledWorker, } from './types.js';
+export { WorkerSigningPool, getSigningPool } from './WorkerSigningPool.js';
+export { generateWorkerCode, createWorkerBlobUrl, revokeWorkerBlobUrl } from './signing-worker.js';
+export { ECC_BUNDLE, ECC_BUNDLE_SIZE } from './ecc-bundle.js';
+export { type NodeWorkerPoolConfig } from './WorkerSigningPool.node.js';
+export { signPsbtParallel, prepareSigningTasks, applySignaturesToPsbt, type ParallelSignOptions, type PsbtParallelKeyPair, } from './psbt-parallel.js';
+/**
+ * Detects the runtime environment and returns the appropriate signing pool.
+ *
+ * @returns 'node' for Node.js, 'browser' for browsers, 'unknown' otherwise
+ */
+export declare function detectRuntime(): 'node' | 'browser' | 'unknown';
+/**
+ * Creates a signing pool appropriate for the current runtime.
+ *
+ * In Node.js, uses worker_threads.
+ * In browsers, uses Web Workers.
+ *
+ * @param config - Optional pool configuration
+ * @returns A promise resolving to the initialized signing pool
+ *
+ * @example
+ * ```typescript
+ * import { createSigningPool } from '@btc-vision/bitcoin/workers';
+ *
+ * const pool = await createSigningPool({ workerCount: 4 });
+ * pool.preserveWorkers();
+ *
+ * // Use pool...
+ *
+ * await pool.shutdown();
+ * ```
+ */
+export declare function createSigningPool(config?: import('./types.js').WorkerPoolConfig): Promise<{
+    signBatch: (tasks: readonly import('./types.js').SigningTask[], keyPair: import('./types.js').ParallelSignerKeyPair) => Promise<import('./types.js').ParallelSigningResult>;
+    preserveWorkers: () => void;
+    releaseWorkers: () => void;
+    shutdown: () => Promise<void>;
+    workerCount: number;
+    idleWorkerCount: number;
+    busyWorkerCount: number;
+    isPreservingWorkers: boolean;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/browser/workers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/workers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAGH,OAAO,EACH,aAAa,EACb,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,yBAAyB,EAC9B,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,cAAc,EACnB,cAAc,EACd,eAAe,EACf,aAAa,EACb,aAAa,EACb,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAChB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,WAAW,EACX,KAAK,YAAY,GACpB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAG3E,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAGnG,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAG9D,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAGxE,OAAO,EACH,gBAAgB,EAChB,mBAAmB,EACnB,qBAAqB,EACrB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,GAC3B,MAAM,oBAAoB,CAAC;AAE5B;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,MAAM,GAAG,SAAS,GAAG,SAAS,CAQ9D;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,CAAC,EAAE,OAAO,YAAY,EAAE,gBAAgB,GAAG,OAAO,CAAC;IAC7F,SAAS,EAAE,CACP,KAAK,EAAE,SAAS,OAAO,YAAY,EAAE,WAAW,EAAE,EAClD,OAAO,EAAE,OAAO,YAAY,EAAE,qBAAqB,KAClD,OAAO,CAAC,OAAO,YAAY,EAAE,qBAAqB,CAAC,CAAC;IACzD,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,mBAAmB,EAAE,OAAO,CAAC;CAChC,CAAC,CAiBD"}

package/browser/workers/psbt-parallel.d.ts

@@ -0,0 +1,88 @@
+import { Psbt } from '../psbt.js';
+import { SigningTask, ParallelSignerKeyPair, ParallelSigningResult, WorkerPoolConfig } from './types.js';
+import { WorkerSigningPool } from './WorkerSigningPool.js';
+/**
+ * Options for parallel PSBT signing.
+ */
+export interface ParallelSignOptions {
+    /**
+     * Sighash types allowed for signing.
+     * Default: [SIGHASH_ALL] for legacy, [SIGHASH_DEFAULT] for Taproot
+     */
+    readonly sighashTypes?: readonly number[];
+    /**
+     * Tap leaf hash to sign (for Taproot script-path).
+     */
+    readonly tapLeafHash?: Uint8Array;
+    /**
+     * Worker pool configuration (if pool not provided).
+     */
+    readonly poolConfig?: WorkerPoolConfig;
+    /**
+     * Whether to use low-R signing for ECDSA.
+     * Default: false
+     */
+    readonly lowR?: boolean;
+}
+/**
+ * Key pair interface that extends ParallelSignerKeyPair with PSBT compatibility.
+ */
+export interface PsbtParallelKeyPair extends ParallelSignerKeyPair {
+    /** Network (optional, for validation) */
+    readonly network?: {
+        messagePrefix: string;
+    };
+}
+/**
+ * Signs all PSBT inputs in parallel using worker threads.
+ *
+ * This is the main entry point for parallel PSBT signing.
+ * All inputs that can be signed with the provided key pair
+ * will be signed simultaneously.
+ *
+ * SECURITY: Private keys are isolated per-worker and zeroed after signing.
+ *
+ * @param psbt - The PSBT to sign
+ * @param keyPair - Key pair with getPrivateKey() method
+ * @param poolOrConfig - Existing pool instance or configuration for new pool
+ * @param options - Signing options
+ * @returns Promise resolving to signing result
+ *
+ * @example
+ * ```typescript
+ * // With existing pool (recommended for multiple operations)
+ * const pool = WorkerSigningPool.getInstance();
+ * pool.preserveWorkers();
+ *
+ * const result = await signPsbtParallel(psbt, keyPair, pool);
+ *
+ * if (result.success) {
+ *     psbt.finalizeAllInputs();
+ * }
+ *
+ * // With inline pool (creates and destroys pool)
+ * const result = await signPsbtParallel(psbt, keyPair, { workerCount: 4 });
+ * ```
+ */
+export declare function signPsbtParallel(psbt: Psbt, keyPair: PsbtParallelKeyPair, poolOrConfig?: WorkerSigningPool | WorkerPoolConfig, options?: ParallelSignOptions): Promise<ParallelSigningResult>;
+/**
+ * Prepares signing tasks from a PSBT.
+ *
+ * Analyzes each input and creates a signing task for inputs
+ * that can be signed with the provided key pair.
+ *
+ * @param psbt - The PSBT to analyze
+ * @param keyPair - Key pair to check against
+ * @param options - Signing options
+ * @returns Array of signing tasks
+ */
+export declare function prepareSigningTasks(psbt: Psbt, keyPair: PsbtParallelKeyPair, options?: ParallelSignOptions): SigningTask[];
+/**
+ * Applies parallel signing results to a PSBT.
+ *
+ * @param psbt - The PSBT to update
+ * @param result - Signing results from parallel signing
+ * @param keyPair - Key pair used for signing
+ */
+export declare function applySignaturesToPsbt(psbt: Psbt, result: ParallelSigningResult, keyPair: PsbtParallelKeyPair): void;
+//# sourceMappingURL=psbt-parallel.d.ts.map

package/browser/workers/psbt-parallel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"psbt-parallel.d.ts","sourceRoot":"","sources":["../../src/workers/psbt-parallel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEvC,OAAO,KAAK,EACR,WAAW,EACX,qBAAqB,EACrB,qBAAqB,EACrB,gBAAgB,EACnB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAK3D;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAChC;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAE1C;;OAEG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,UAAU,CAAC;IAElC;;OAEG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAEvC;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,qBAAqB;IAC9D,yCAAyC;IACzC,QAAQ,CAAC,OAAO,CAAC,EAAE;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC;CAChD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,gBAAgB,CAClC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,mBAAmB,EAC5B,YAAY,CAAC,EAAE,iBAAiB,GAAG,gBAAgB,EACnD,OAAO,GAAE,mBAAwB,GAClC,OAAO,CAAC,qBAAqB,CAAC,CA4ChC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAC/B,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,mBAAmB,EAC5B,OAAO,GAAE,mBAAwB,GAClC,WAAW,EAAE,CA4Bf;AAuED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACjC,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,qBAAqB,EAC7B,OAAO,EAAE,mBAAmB,GAC7B,IAAI,CAyCN"}

package/browser/workers/signing-worker.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Inline signing worker code.
+ *
+ * This module generates the worker code as a string that can be
+ * loaded via Blob URL. The worker uses the bundled @noble/secp256k1
+ * library embedded at compile time - no network requests required.
+ *
+ * SECURITY CRITICAL:
+ * - Private keys are zeroed immediately after signing
+ * - No key data is logged or stored
+ * - Worker only holds key during active signing operation
+ * - ECC library is bundled at compile time (no CDN dependency)
+ *
+ * @packageDocumentation
+ */
+/**
+ * Generates the inline worker code as a string.
+ *
+ * The worker uses the bundled @noble/secp256k1 library directly,
+ * eliminating any network dependencies.
+ *
+ * @returns Worker code as a string for Blob URL creation
+ */
+export declare function generateWorkerCode(): string;
+/**
+ * Creates a Blob URL for the worker code.
+ *
+ * @returns Blob URL that can be used with new Worker()
+ */
+export declare function createWorkerBlobUrl(): string;
+/**
+ * Revokes a previously created worker Blob URL.
+ *
+ * @param url - The Blob URL to revoke
+ */
+export declare function revokeWorkerBlobUrl(url: string): void;
+//# sourceMappingURL=signing-worker.d.ts.map

package/browser/workers/signing-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signing-worker.d.ts","sourceRoot":"","sources":["../../src/workers/signing-worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAkT3C;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAI5C;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAErD"}

package/browser/workers/types.d.ts

@@ -0,0 +1,365 @@
+/**
+ * Worker thread types for parallel signing operations.
+ *
+ * SECURITY NOTES:
+ * - Private keys are NEVER shared via SharedArrayBuffer
+ * - Keys are cloned via postMessage (isolated per worker)
+ * - Keys are zeroed immediately after signing
+ * - Workers are pooled for performance but keys don't persist
+ *
+ * @packageDocumentation
+ */
+/**
+ * Signature type enum for worker operations.
+ */
+export declare const SignatureType: {
+    /** ECDSA signature (secp256k1) */
+    readonly ECDSA: 0;
+    /** Schnorr signature (BIP340) */
+    readonly Schnorr: 1;
+};
+export type SignatureType = (typeof SignatureType)[keyof typeof SignatureType];
+/**
+ * Message sent to worker for signing operation.
+ *
+ * SECURITY: privateKey is cloned via postMessage, NOT shared.
+ * Worker MUST zero the key after signing.
+ */
+export interface SigningTaskMessage {
+    /** Message type discriminator */
+    readonly type: 'sign';
+    /** Task identifier for correlation */
+    readonly taskId: string;
+    /** Hash to sign (32 bytes) */
+    readonly hash: Uint8Array;
+    /** Private key (32 bytes) - WILL BE ZEROED after use */
+    readonly privateKey: Uint8Array;
+    /** Public key for verification (33 or 65 bytes) */
+    readonly publicKey: Uint8Array;
+    /** Signature type (ECDSA or Schnorr) */
+    readonly signatureType: SignatureType;
+    /** Low R signing for ECDSA (optional) */
+    readonly lowR?: boolean | undefined;
+    /** Input index this signature is for */
+    readonly inputIndex: number;
+    /** Sighash type for encoding */
+    readonly sighashType: number;
+    /** Leaf hash for Taproot script-path (optional) */
+    readonly leafHash?: Uint8Array | undefined;
+}
+/**
+ * Initialization message for worker with ECC library.
+ */
+export interface WorkerInitMessage {
+    /** Message type discriminator */
+    readonly type: 'init';
+    /** Serialized ECC library functions (or library identifier) */
+    readonly eccLibId: string;
+}
+/**
+ * Shutdown message for worker.
+ */
+export interface WorkerShutdownMessage {
+    /** Message type discriminator */
+    readonly type: 'shutdown';
+}
+/**
+ * Individual task in a batch (without privateKey - shared across batch).
+ */
+export interface BatchSigningTask {
+    /** Task identifier */
+    readonly taskId: string;
+    /** Hash to sign (32 bytes) */
+    readonly hash: Uint8Array;
+    /** Public key for verification */
+    readonly publicKey: Uint8Array;
+    /** Signature type */
+    readonly signatureType: SignatureType;
+    /** Low R for ECDSA */
+    readonly lowR?: boolean | undefined;
+    /** Input index */
+    readonly inputIndex: number;
+    /** Sighash type */
+    readonly sighashType: number;
+    /** Leaf hash for Taproot */
+    readonly leafHash?: Uint8Array | undefined;
+}
+/**
+ * Batch signing message - multiple tasks with single private key.
+ * More efficient than sending tasks one at a time.
+ */
+export interface BatchSigningMessage {
+    /** Message type discriminator */
+    readonly type: 'signBatch';
+    /** Batch identifier for correlation */
+    readonly batchId: string;
+    /** Tasks to sign */
+    readonly tasks: readonly BatchSigningTask[];
+    /** Private key (32 bytes) - WILL BE ZEROED after all tasks */
+    readonly privateKey: Uint8Array;
+}
+/**
+ * Individual result from a batch.
+ */
+export interface BatchSigningTaskResult {
+    /** Task identifier */
+    readonly taskId: string;
+    /** Signature bytes */
+    readonly signature: Uint8Array;
+    /** Input index */
+    readonly inputIndex: number;
+    /** Public key used */
+    readonly publicKey: Uint8Array;
+    /** Signature type */
+    readonly signatureType: SignatureType;
+    /** Leaf hash (if applicable) */
+    readonly leafHash?: Uint8Array | undefined;
+}
+/**
+ * Individual error from a batch.
+ */
+export interface BatchSigningTaskError {
+    /** Task identifier */
+    readonly taskId: string;
+    /** Input index */
+    readonly inputIndex: number;
+    /** Error message */
+    readonly error: string;
+}
+/**
+ * Batch result message from worker.
+ */
+export interface BatchSigningResultMessage {
+    /** Message type discriminator */
+    readonly type: 'batchResult';
+    /** Batch identifier for correlation */
+    readonly batchId: string;
+    /** Successful results */
+    readonly results: readonly BatchSigningTaskResult[];
+    /** Errors */
+    readonly errors: readonly BatchSigningTaskError[];
+}
+/**
+ * All possible messages to worker.
+ */
+export type WorkerMessage = SigningTaskMessage | BatchSigningMessage | WorkerInitMessage | WorkerShutdownMessage;
+/**
+ * Result from worker after signing.
+ */
+export interface SigningResultMessage {
+    /** Message type discriminator */
+    readonly type: 'result';
+    /** Task identifier for correlation */
+    readonly taskId: string;
+    /** Signature bytes (64 bytes raw for Schnorr, or with sighash for ECDSA) */
+    readonly signature: Uint8Array;
+    /** Input index this signature is for */
+    readonly inputIndex: number;
+    /** Public key used for signing */
+    readonly publicKey: Uint8Array;
+    /** Signature type that was used */
+    readonly signatureType: SignatureType;
+    /** Leaf hash for Taproot script-path spending (if applicable) */
+    readonly leafHash?: Uint8Array | undefined;
+}
+/**
+ * Error result from worker.
+ */
+export interface SigningErrorMessage {
+    /** Message type discriminator */
+    readonly type: 'error';
+    /** Task identifier for correlation */
+    readonly taskId: string;
+    /** Error message */
+    readonly error: string;
+    /** Input index that failed */
+    readonly inputIndex: number;
+}
+/**
+ * Worker ready message.
+ */
+export interface WorkerReadyMessage {
+    /** Message type discriminator */
+    readonly type: 'ready';
+}
+/**
+ * Worker shutdown acknowledgment.
+ */
+export interface WorkerShutdownAckMessage {
+    /** Message type discriminator */
+    readonly type: 'shutdown-ack';
+}
+/**
+ * Union of all worker response types.
+ */
+export type WorkerResponse = SigningResultMessage | SigningErrorMessage | BatchSigningResultMessage | WorkerReadyMessage | WorkerShutdownAckMessage;
+/**
+ * Type guard for error responses.
+ */
+export declare function isSigningError(response: WorkerResponse): response is SigningErrorMessage;
+/**
+ * Type guard for success responses.
+ */
+export declare function isSigningResult(response: WorkerResponse): response is SigningResultMessage;
+/**
+ * Type guard for batch result responses.
+ */
+export declare function isBatchResult(response: WorkerResponse): response is BatchSigningResultMessage;
+/**
+ * Type guard for ready responses.
+ */
+export declare function isWorkerReady(response: WorkerResponse): response is WorkerReadyMessage;
+/**
+ * Interface for the ECC library used by workers.
+ * Provides signing functions for ECDSA and Schnorr signatures.
+ */
+export interface WorkerEccLib {
+    /**
+     * Create an ECDSA signature.
+     *
+     * @param hash - 32-byte hash to sign
+     * @param privateKey - 32-byte private key
+     * @param lowR - Optional: grind for low R value
+     * @returns 64-byte raw signature (r || s)
+     */
+    sign(hash: Uint8Array, privateKey: Uint8Array, lowR?: boolean): Uint8Array;
+    /**
+     * Create a Schnorr signature (BIP340).
+     *
+     * @param hash - 32-byte hash to sign
+     * @param privateKey - 32-byte private key
+     * @returns 64-byte Schnorr signature
+     */
+    signSchnorr(hash: Uint8Array, privateKey: Uint8Array): Uint8Array;
+}
+/**
+ * Configuration for the worker signing pool.
+ */
+export interface WorkerPoolConfig {
+    /**
+     * Number of workers to create.
+     * Default: number of CPU cores (navigator.hardwareConcurrency or os.cpus().length)
+     */
+    readonly workerCount?: number;
+    /**
+     * Timeout per signing operation in milliseconds.
+     * Worker is terminated if exceeded (key safety measure).
+     * Default: 30000 (30 seconds)
+     */
+    readonly taskTimeoutMs?: number;
+    /**
+     * Maximum time a worker can hold a private key in milliseconds.
+     * Acts as a safety net - worker is terminated if signing takes too long.
+     * Default: 5000 (5 seconds)
+     */
+    readonly maxKeyHoldTimeMs?: number;
+    /**
+     * Whether to verify signatures after signing.
+     * Adds overhead but ensures correctness.
+     * Default: true
+     */
+    readonly verifySignatures?: boolean;
+    /**
+     * Whether to preserve workers between signing batches.
+     * true = workers stay alive (faster for multiple batches)
+     * false = workers terminated after each batch (more secure)
+     * Default: true (use preserveWorkers() to enable)
+     */
+    readonly preserveWorkers?: boolean;
+}
+/**
+ * Signing task for the worker queue.
+ */
+export interface SigningTask {
+    /** Task identifier */
+    readonly taskId: string;
+    /** Input index */
+    readonly inputIndex: number;
+    /** Hash to sign (32 bytes) */
+    readonly hash: Uint8Array;
+    /** Signature type */
+    readonly signatureType: SignatureType;
+    /** Low R for ECDSA */
+    readonly lowR?: boolean | undefined;
+    /** Sighash type */
+    readonly sighashType: number;
+    /** Leaf hash for Taproot script-path */
+    readonly leafHash?: Uint8Array | undefined;
+}
+/**
+ * Signer key pair interface for parallel signing.
+ *
+ * SECURITY: getPrivateKey() is only called when dispatching to worker.
+ * The returned bytes are cloned to the worker and then the original
+ * should be considered potentially compromised (in main thread memory).
+ *
+ * For maximum security, use a hardware wallet that never exposes keys.
+ */
+export interface ParallelSignerKeyPair {
+    /** Public key (compressed 33 bytes or uncompressed 65 bytes) */
+    readonly publicKey: Uint8Array;
+    /**
+     * Get private key bytes (32 bytes).
+     *
+     * SECURITY WARNING: This exposes the raw private key.
+     * - Called only when dispatching to worker
+     * - Key is cloned to worker via postMessage
+     * - Original in main thread should be zeroed by caller if possible
+     *
+     * For high-security applications, use hardware wallets instead.
+     */
+    getPrivateKey(): Uint8Array;
+    /**
+     * Optional: Sign ECDSA directly (fallback if workers unavailable).
+     */
+    sign?(hash: Uint8Array, lowR?: boolean): Uint8Array;
+    /**
+     * Optional: Sign Schnorr directly (fallback if workers unavailable).
+     */
+    signSchnorr?(hash: Uint8Array): Uint8Array;
+}
+/**
+ * Result of a parallel signing batch.
+ */
+export interface ParallelSigningResult {
+    /** Whether all signatures were created successfully */
+    readonly success: boolean;
+    /** Signatures indexed by input index */
+    readonly signatures: ReadonlyMap<number, SigningResultMessage>;
+    /** Errors indexed by input index */
+    readonly errors: ReadonlyMap<number, string>;
+    /** Total time taken in milliseconds */
+    readonly durationMs: number;
+}
+/**
+ * Worker state for pool management.
+ */
+export declare const WorkerState: {
+    /** Worker is initializing */
+    readonly Initializing: 0;
+    /** Worker is ready and idle */
+    readonly Idle: 1;
+    /** Worker is processing a task */
+    readonly Busy: 2;
+    /** Worker is shutting down */
+    readonly ShuttingDown: 3;
+    /** Worker has terminated */
+    readonly Terminated: 4;
+};
+export type WorkerState = (typeof WorkerState)[keyof typeof WorkerState];
+/**
+ * Internal worker wrapper for pool management.
+ */
+export interface PooledWorker {
+    /** Unique worker identifier */
+    readonly id: number;
+    /** Current worker state */
+    state: WorkerState;
+    /** The actual worker instance */
+    readonly worker: Worker;
+    /** Current task ID (if busy) */
+    currentTaskId: string | null;
+    /** Timestamp when current task started */
+    taskStartTime: number | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/browser/workers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/workers/types.ts"],"names":[],"mappings":"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"}