@btc-vision/bitcoin 7.0.0-alpha.3 → 7.0.0-alpha.5

package/src/io/index.ts

@@ -34,8 +34,5 @@ export {
     toUtf8,
 } from './utils.js';
 
-// Memory pools
-export { MemoryPool, SimpleMemoryPool } from './MemoryPool.js';
-
 // Re-export varuint for Bitcoin CompactSize encoding
 export { varuint };

package/src/types.ts

@@ -17,10 +17,6 @@ import type {
     XOnlyPublicKey,
 } from './branded.js';
 
-// ============================================================================
-// Branded Types (re-exported from branded.ts to avoid circular dependencies)
-// ============================================================================
-
 export type {
     Bytes32,
     Bytes20,
@@ -34,22 +30,15 @@ export type {
     Script,
 } from './branded.js';
 
-// ============================================================================
-// Constants
-// ============================================================================
-
 /** @internal Do not mutate */
 const EC_P = fromHex('fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f');
+
 /** @internal Do not mutate — secp256k1 curve order */
 const EC_N = fromHex('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141');
 
 export const SATOSHI_MAX = 21n * 10n ** 14n;
 export const TAPLEAF_VERSION_MASK = 0xfe;
 
-// ============================================================================
-// Type Guards
-// ============================================================================
-
 export function isUInt8(value: unknown): value is number {
     return typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= 0xff;
 }
@@ -96,8 +85,7 @@ export function isBytes20(value: unknown): value is Bytes20 {
 export function isXOnlyPublicKey(value: unknown): value is XOnlyPublicKey {
     if (!(value instanceof Uint8Array) || value.length !== 32) return false;
     if (isZero(value)) return false;
-    if (compare(value, EC_P) >= 0) return false;
-    return true;
+    return compare(value, EC_P) < 0;
 }
 
 export function isPoint(value: unknown): value is PublicKey {
@@ -130,8 +118,7 @@ export function isSatoshi(value: unknown): value is Satoshi {
 export function isPrivateKey(value: unknown): value is PrivateKey {
     if (!(value instanceof Uint8Array) || value.length !== 32) return false;
     if (isZero(value)) return false;
-    if (compare(value, EC_N) >= 0) return false;
-    return true;
+    return compare(value, EC_N) < 0;
 }
 
 export function isSchnorrSignature(value: unknown): value is SchnorrSignature {
@@ -146,9 +133,7 @@ export function isScript(value: unknown): value is Script {
     return value instanceof Uint8Array;
 }
 
-// ============================================================================
 // Taproot Types
-// ============================================================================
 
 export interface Tapleaf {
     readonly output: Uint8Array;
@@ -178,23 +163,17 @@ export function isTaptree(value: unknown): value is Taptree {
     return value.every((node: unknown) => isTaptree(node));
 }
 
-// ============================================================================
-// ECC Interface (re-exported from ecc/types.ts for backward compatibility)
-// ============================================================================
+// ECC Interface
 
 export type { CryptoBackend, XOnlyPointAddTweakResult, EccLib, Parity } from './ecc/types.js';
 
-// ============================================================================
 // Stack Types
-// ============================================================================
 
 export type StackElement = Uint8Array | number;
 export type Stack = readonly StackElement[];
 export type StackFunction = () => Stack;
 
-// ============================================================================
 // Utility Functions
-// ============================================================================
 
 export function stacksEqual(a: Uint8Array[], b: Uint8Array[]): boolean {
     if (a.length !== b.length) return false;
@@ -236,9 +215,7 @@ export function toSatoshi(value: bigint): Satoshi {
     return value as Satoshi;
 }
 
-// ============================================================================
 // Assertion Helpers
-// ============================================================================
 
 export function assertXOnlyPublicKey(
     value: unknown,

package/src/workers/WorkerSigningPool.node.ts

@@ -353,6 +353,15 @@ export class NodeWorkerSigningPool {
         }
     }
 
+    /**
+     * Disposes of the pool by shutting down all workers.
+     *
+     * Enables `await using pool = ...` syntax for automatic cleanup.
+     */
+    public async [Symbol.asyncDispose](): Promise<void> {
+        await this.shutdown();
+    }
+
     /**
      * Shuts down the pool and terminates all workers.
      *
@@ -384,7 +393,7 @@ export class NodeWorkerSigningPool {
      */
     #createWorkerScript(): string {
         // Node.js worker_threads can directly require/import modules
-        const workerCode = `
+        return `
 const { parentPort } = require('worker_threads');
 
 /**
@@ -649,7 +658,6 @@ function handleSignBatch(msg) {
     });
 }
 `;
-        return workerCode;
     }
 
     /**

package/src/workers/WorkerSigningPool.sequential.ts

@@ -0,0 +1,190 @@
+/**
+ * Sequential signing pool for environments without worker support (React Native).
+ *
+ * Signs inputs one-by-one on the main thread using the CryptoBackend
+ * from EccContext. Same API shape as WorkerSigningPool so consumers
+ * can swap transparently.
+ *
+ * @packageDocumentation
+ */
+
+import type {
+    ParallelSignerKeyPair,
+    ParallelSigningResult,
+    SigningResultMessage,
+    SigningTask,
+    WorkerPoolConfig,
+} from './types.js';
+import { SignatureType } from './types.js';
+import { EccContext } from '../ecc/context.js';
+import type { MessageHash, PrivateKey } from '@btc-vision/ecpair';
+
+/**
+ * Sequential signing pool — signs inputs one-by-one on the main thread.
+ *
+ * Provides the same public API as WorkerSigningPool but without any
+ * threading. Intended for React Native or other environments where
+ * Web Workers and worker_threads are unavailable.
+ *
+ * @example
+ * ```typescript
+ * import { SequentialSigningPool } from '@btc-vision/bitcoin/workers';
+ *
+ * const pool = SequentialSigningPool.getInstance();
+ * const result = await pool.signBatch(tasks, keyPair);
+ * ```
+ */
+export class SequentialSigningPool {
+    static #instance: SequentialSigningPool | null = null;
+
+    private constructor(_config: WorkerPoolConfig = {}) {
+        // Config accepted for API compatibility but not used —
+        // sequential pool has no workers to configure.
+    }
+
+    /**
+     * Number of workers — always 0 for sequential pool.
+     */
+    public get workerCount(): number {
+        return 0;
+    }
+
+    /**
+     * Idle workers — always 0.
+     */
+    public get idleWorkerCount(): number {
+        return 0;
+    }
+
+    /**
+     * Busy workers — always 0.
+     */
+    public get busyWorkerCount(): number {
+        return 0;
+    }
+
+    /**
+     * Whether workers are preserved — always false (no workers to preserve).
+     */
+    public get isPreservingWorkers(): boolean {
+        return false;
+    }
+
+    /**
+     * Gets the singleton instance.
+     */
+    public static getInstance(config?: WorkerPoolConfig): SequentialSigningPool {
+        if (!SequentialSigningPool.#instance) {
+            SequentialSigningPool.#instance = new SequentialSigningPool(config);
+        }
+        return SequentialSigningPool.#instance;
+    }
+
+    /**
+     * Resets the singleton instance (for testing).
+     */
+    public static resetInstance(): void {
+        SequentialSigningPool.#instance = null;
+    }
+
+    /**
+     * No-op — no workers to preserve.
+     */
+    public preserveWorkers(): void {
+        // No-op: no workers to preserve
+    }
+
+    /**
+     * No-op — no workers to release.
+     */
+    public releaseWorkers(): void {
+        // No-op
+    }
+
+    /**
+     * No-op — no initialization required.
+     */
+    public async initialize(): Promise<void> {
+        // No-op: nothing to initialize
+    }
+
+    /**
+     * Signs tasks sequentially on the main thread.
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    public async signBatch(
+        tasks: readonly SigningTask[],
+        keyPair: ParallelSignerKeyPair,
+    ): Promise<ParallelSigningResult> {
+        const startTime = performance.now();
+
+        if (tasks.length === 0) {
+            return {
+                success: true,
+                signatures: new Map(),
+                errors: new Map(),
+                durationMs: performance.now() - startTime,
+            };
+        }
+
+        const ecc = EccContext.get().lib;
+        const privateKey = keyPair.getPrivateKey();
+
+        const signatures = new Map<number, SigningResultMessage>();
+        const errors = new Map<number, string>();
+
+        try {
+            for (const task of tasks) {
+                try {
+                    let signature: Uint8Array;
+
+                    const hash = task.hash as MessageHash;
+                    const key = privateKey as PrivateKey;
+
+                    if (task.signatureType === SignatureType.Schnorr) {
+                        signature = ecc.signSchnorr!(hash, key);
+                    } else {
+                        signature = ecc.sign(hash, key);
+                    }
+
+                    signatures.set(task.inputIndex, {
+                        type: 'result',
+                        taskId: task.taskId,
+                        signature,
+                        inputIndex: task.inputIndex,
+                        publicKey: keyPair.publicKey,
+                        signatureType: task.signatureType,
+                        leafHash: task.leafHash,
+                    });
+                } catch (err: unknown) {
+                    const message = err instanceof Error ? err.message : 'Signing failed';
+                    errors.set(task.inputIndex, message);
+                }
+            }
+        } finally {
+            // SECURITY: Zero the private key
+            privateKey.fill(0);
+        }
+
+        return {
+            success: errors.size === 0,
+            signatures,
+            errors,
+            durationMs: performance.now() - startTime,
+        };
+    }
+
+    /**
+     * No-op — no workers to shut down.
+     */
+    public async shutdown(): Promise<void> {
+        // No-op: nothing to shut down
+    }
+
+    /**
+     * Enables `await using pool = ...` syntax.
+     */
+    public async [Symbol.asyncDispose](): Promise<void> {
+        await this.shutdown();
+    }
+}

package/src/workers/WorkerSigningPool.ts

@@ -389,6 +389,15 @@ export class WorkerSigningPool {
         }
     }
 
+    /**
+     * Disposes of the pool by shutting down all workers.
+     *
+     * Enables `await using pool = ...` syntax for automatic cleanup.
+     */
+    public async [Symbol.asyncDispose](): Promise<void> {
+        await this.shutdown();
+    }
+
     /**
      * Shuts down the pool and terminates all workers.
      *