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

package/src/workers/index.shared.ts

@@ -0,0 +1,58 @@
+/**
+ * Shared worker module exports.
+ *
+ * Contains all platform-agnostic exports used by browser, Node.js, and generic
+ * entry points. Platform-specific entry points re-export from this module and
+ * add their own `detectRuntime` and `createSigningPool` implementations.
+ *
+ * @packageDocumentation
+ */
+
+// Type exports
+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,
+    type SigningPoolLike,
+    WorkerState,
+    type PooledWorker,
+} from './types.js';
+
+// Browser worker pool
+export { WorkerSigningPool, getSigningPool } from './WorkerSigningPool.js';
+
+// Worker code generation (for custom implementations)
+export { generateWorkerCode, createWorkerBlobUrl, revokeWorkerBlobUrl } from './signing-worker.js';
+
+// ECC bundle (for embedding in custom workers)
+export { ECC_BUNDLE, ECC_BUNDLE_SIZE } from './ecc-bundle.js';
+
+// PSBT parallel signing integration
+export {
+    signPsbtParallel,
+    prepareSigningTasks,
+    applySignaturesToPsbt,
+    type ParallelSignOptions,
+    type PsbtParallelKeyPair,
+} from './psbt-parallel.js';

package/src/workers/index.ts

@@ -1,8 +1,9 @@
 /**
- * Worker-based parallel signing module.
+ * Worker-based parallel signing module (generic entry point).
  *
  * Provides secure parallel signature computation using worker threads.
  * Works in both Node.js (worker_threads) and browsers (Web Workers).
+ * Uses runtime detection to select the appropriate pool implementation.
  *
  * @example
  * ```typescript
@@ -46,62 +47,19 @@
  * @packageDocumentation
  */
 
-import type { WorkerPoolConfig, SigningTask, ParallelSignerKeyPair, ParallelSigningResult } from './types.js';
+import type { WorkerPoolConfig, SigningPoolLike } from './types.js';
 
-// Type exports
-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';
-
-// Browser worker pool
-export { WorkerSigningPool, getSigningPool } from './WorkerSigningPool.js';
-
-// Worker code generation (for custom implementations)
-export { generateWorkerCode, createWorkerBlobUrl, revokeWorkerBlobUrl } from './signing-worker.js';
-
-// ECC bundle (for embedding in custom workers)
-export { ECC_BUNDLE, ECC_BUNDLE_SIZE } from './ecc-bundle.js';
-
-// PSBT parallel signing integration
-export {
-    signPsbtParallel,
-    prepareSigningTasks,
-    applySignaturesToPsbt,
-    type ParallelSignOptions,
-    type PsbtParallelKeyPair,
-} from './psbt-parallel.js';
+export * from './index.shared.js';
 
 /**
  * Detects the runtime environment and returns the appropriate signing pool.
  *
  * @returns 'node' for Node.js, 'browser' for browsers, 'unknown' otherwise
  */
-export function detectRuntime(): 'node' | 'browser' | 'unknown' {
+export function detectRuntime(): 'node' | 'browser' | 'react-native' | 'unknown' {
+    if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
+        return 'react-native';
+    }
     if (typeof process !== 'undefined' && process.versions?.node) {
         return 'node';
     }
@@ -132,19 +90,7 @@ export function detectRuntime(): 'node' | 'browser' | 'unknown' {
  * await pool.shutdown();
  * ```
  */
-export async function createSigningPool(config?: WorkerPoolConfig): Promise<{
-    signBatch: (
-        tasks: readonly SigningTask[],
-        keyPair: ParallelSignerKeyPair,
-    ) => Promise<ParallelSigningResult>;
-    preserveWorkers: () => void;
-    releaseWorkers: () => void;
-    shutdown: () => Promise<void>;
-    workerCount: number;
-    idleWorkerCount: number;
-    busyWorkerCount: number;
-    isPreservingWorkers: boolean;
-}> {
+export async function createSigningPool(config?: WorkerPoolConfig): Promise<SigningPoolLike> {
     const runtime = detectRuntime();
 
     if (runtime === 'node') {
@@ -157,7 +103,12 @@ export async function createSigningPool(config?: WorkerPoolConfig): Promise<{
         const pool = WorkerSigningPool.getInstance(config);
         await pool.initialize();
         return pool;
+    } else if (runtime === 'react-native') {
+        const { SequentialSigningPool } = await import('./WorkerSigningPool.sequential.js');
+        const pool = SequentialSigningPool.getInstance(config);
+        await pool.initialize();
+        return pool;
     } else {
         throw new Error('Unsupported runtime for worker signing pool');
     }
-}
+}

package/src/workers/psbt-parallel.ts

@@ -32,9 +32,8 @@ import type { PsbtInput, TapKeySig, TapScriptSig } from 'bip174';
 import type { PublicKey } from '../types.js';
 import type { Psbt } from '../psbt.js';
 import { Transaction } from '../transaction.js';
-import type { ParallelSignerKeyPair, ParallelSigningResult, SigningTask, WorkerPoolConfig, } from './types.js';
+import type { ParallelSignerKeyPair, ParallelSigningResult, SigningPoolLike, SigningTask, WorkerPoolConfig, } from './types.js';
 import { SignatureType } from './types.js';
-import { WorkerSigningPool } from './WorkerSigningPool.js';
 import { toXOnly } from '../pubkey.js';
 import { isTaprootInput, serializeTaprootSignature } from '../psbt/bip371.js';
 import * as bscript from '../script.js';
@@ -108,17 +107,18 @@ export interface PsbtParallelKeyPair extends ParallelSignerKeyPair {
 export async function signPsbtParallel(
     psbt: Psbt,
     keyPair: PsbtParallelKeyPair,
-    poolOrConfig?: WorkerSigningPool | WorkerPoolConfig,
+    poolOrConfig?: SigningPoolLike | WorkerPoolConfig,
     options: ParallelSignOptions = {},
 ): Promise<ParallelSigningResult> {
     // Get or create pool
-    let pool: WorkerSigningPool;
+    let pool: SigningPoolLike;
     let shouldShutdown = false;
 
-    if (poolOrConfig instanceof WorkerSigningPool) {
+    if (poolOrConfig && 'signBatch' in poolOrConfig) {
         pool = poolOrConfig;
     } else {
-        pool = WorkerSigningPool.getInstance(poolOrConfig);
+        const { WorkerSigningPool } = await import('./WorkerSigningPool.js');
+        pool = WorkerSigningPool.getInstance(poolOrConfig as WorkerPoolConfig | undefined);
         if (!pool.isPreservingWorkers) {
             shouldShutdown = true;
         }
@@ -310,12 +310,12 @@ export function applySignaturesToPsbt(
         } else {
             // ECDSA signature
             const encodedSig = bscript.signature.encode(
-                Buffer.from(sigResult.signature),
+                sigResult.signature,
                 input.sighashType ?? Transaction.SIGHASH_ALL,
             );
             const partialSig = [
                 {
-                    pubkey: Buffer.from(pubkey),
+                    pubkey: Uint8Array.from(pubkey),
                     signature: encodedSig,
                 },
             ];

package/src/workers/types.ts

@@ -400,6 +400,27 @@ export const WorkerState = {
 
 export type WorkerState = (typeof WorkerState)[keyof typeof WorkerState];
 
+/**
+ * Minimum contract for any signing pool implementation.
+ *
+ * Implemented by WorkerSigningPool (browser), NodeWorkerSigningPool (Node.js),
+ * and SequentialSigningPool (React Native / fallback).
+ */
+export interface SigningPoolLike {
+    signBatch(
+        tasks: readonly SigningTask[],
+        keyPair: ParallelSignerKeyPair,
+    ): Promise<ParallelSigningResult>;
+    preserveWorkers(): void;
+    releaseWorkers(): void;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    readonly workerCount: number;
+    readonly idleWorkerCount: number;
+    readonly busyWorkerCount: number;
+    readonly isPreservingWorkers: boolean;
+}
+
 /**
  * Internal worker wrapper for pool management.
  */

package/test/env.spec.ts

@@ -0,0 +1,418 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+
+describe('Runtime capability check — hard requirements', () => {
+    beforeEach(() => {
+        vi.resetModules();
+    });
+
+    afterEach(() => {
+        vi.unstubAllGlobals();
+        vi.restoreAllMocks();
+    });
+
+    it('should pass in a capable environment', async () => {
+        await expect(import('../src/env.js')).resolves.not.toThrow();
+    });
+
+    it('should throw when BigInt is missing', async () => {
+        vi.stubGlobal('BigInt', undefined);
+
+        await expect(import('../src/env.js')).rejects.toThrow('unsupported runtime');
+        await expect(import('../src/env.js')).rejects.toThrow('BigInt');
+    });
+
+    it('should throw when Uint8Array is missing', async () => {
+        vi.stubGlobal('Uint8Array', undefined);
+
+        await expect(import('../src/env.js')).rejects.toThrow('unsupported runtime');
+        await expect(import('../src/env.js')).rejects.toThrow('Uint8Array');
+    });
+
+    it('should throw when DataView.getBigInt64 is missing', async () => {
+        const orig = DataView.prototype.getBigInt64;
+        (DataView.prototype as Record<string, unknown>)['getBigInt64'] = undefined;
+
+        try {
+            await import('../src/env.js');
+            expect.unreachable('should have thrown');
+        } catch (err) {
+            expect((err as Error).message).toContain('getBigInt64');
+        } finally {
+            DataView.prototype.getBigInt64 = orig;
+        }
+    });
+
+    it('should report all missing capabilities at once', async () => {
+        vi.stubGlobal('BigInt', undefined);
+        vi.stubGlobal('Uint8Array', undefined);
+
+        try {
+            await import('../src/env.js');
+            expect.unreachable('should have thrown');
+        } catch (err) {
+            const msg = (err as Error).message;
+            expect(msg).toContain('BigInt');
+            expect(msg).toContain('Uint8Array');
+            expect(msg).toContain('cannot be polyfilled');
+        }
+    });
+});
+
+describe('Polyfill — TextEncoder / TextDecoder', () => {
+    beforeEach(() => {
+        vi.resetModules();
+    });
+
+    afterEach(() => {
+        vi.unstubAllGlobals();
+        vi.restoreAllMocks();
+    });
+
+    it('should polyfill TextEncoder when missing', async () => {
+        vi.stubGlobal('TextEncoder', undefined);
+
+        await import('../src/env.js');
+
+        const encoder = new globalThis.TextEncoder();
+        const result = encoder.encode('hello');
+        expect(result).toBeInstanceOf(Uint8Array);
+        expect(Array.from(result)).toEqual([0x68, 0x65, 0x6c, 0x6c, 0x6f]);
+    });
+
+    it('should encode multi-byte UTF-8 correctly', async () => {
+        vi.stubGlobal('TextEncoder', undefined);
+
+        await import('../src/env.js');
+
+        const encoder = new globalThis.TextEncoder();
+        // 2-byte: é (U+00E9)
+        const twoB = encoder.encode('é');
+        expect(Array.from(twoB)).toEqual([0xc3, 0xa9]);
+
+        // 3-byte: € (U+20AC)
+        const threeB = encoder.encode('€');
+        expect(Array.from(threeB)).toEqual([0xe2, 0x82, 0xac]);
+    });
+
+    it('should encode surrogate pairs (4-byte UTF-8)', async () => {
+        vi.stubGlobal('TextEncoder', undefined);
+
+        await import('../src/env.js');
+
+        const encoder = new globalThis.TextEncoder();
+        // U+1F600 (😀) = F0 9F 98 80
+        const emoji = encoder.encode('😀');
+        expect(Array.from(emoji)).toEqual([0xf0, 0x9f, 0x98, 0x80]);
+    });
+
+    it('should polyfill TextDecoder when missing', async () => {
+        vi.stubGlobal('TextDecoder', undefined);
+
+        await import('../src/env.js');
+
+        const decoder = new globalThis.TextDecoder();
+        const result = decoder.decode(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f]));
+        expect(result).toBe('hello');
+    });
+
+    it('should decode multi-byte UTF-8 correctly', async () => {
+        vi.stubGlobal('TextDecoder', undefined);
+
+        await import('../src/env.js');
+
+        const decoder = new globalThis.TextDecoder();
+        expect(decoder.decode(new Uint8Array([0xc3, 0xa9]))).toBe('é');
+        expect(decoder.decode(new Uint8Array([0xe2, 0x82, 0xac]))).toBe('€');
+    });
+
+    it('should decode surrogate pairs (4-byte UTF-8)', async () => {
+        vi.stubGlobal('TextDecoder', undefined);
+
+        await import('../src/env.js');
+
+        const decoder = new globalThis.TextDecoder();
+        expect(decoder.decode(new Uint8Array([0xf0, 0x9f, 0x98, 0x80]))).toBe('😀');
+    });
+
+    it('should round-trip encode/decode', async () => {
+        vi.stubGlobal('TextEncoder', undefined);
+        vi.stubGlobal('TextDecoder', undefined);
+
+        await import('../src/env.js');
+
+        const input = 'Hello, 世界! 🚀';
+        const encoder = new globalThis.TextEncoder();
+        const decoder = new globalThis.TextDecoder();
+        expect(decoder.decode(encoder.encode(input))).toBe(input);
+    });
+
+    it('should not replace native TextEncoder', async () => {
+        const NativeTextEncoder = globalThis.TextEncoder;
+
+        await import('../src/env.js');
+
+        expect(globalThis.TextEncoder).toBe(NativeTextEncoder);
+    });
+});
+
+describe('Polyfill — Map', () => {
+    beforeEach(() => {
+        vi.resetModules();
+    });
+
+    afterEach(() => {
+        vi.unstubAllGlobals();
+        vi.restoreAllMocks();
+    });
+
+    it('should polyfill Map when missing', async () => {
+        vi.stubGlobal('Map', undefined);
+
+        await import('../src/env.js');
+
+        const map = new globalThis.Map<string, number>();
+        map.set('a', 1);
+        map.set('b', 2);
+        expect(map.size).toBe(2);
+        expect(map.get('a')).toBe(1);
+        expect(map.has('b')).toBe(true);
+        expect(map.has('c')).toBe(false);
+    });
+
+    it('should support delete and clear', async () => {
+        vi.stubGlobal('Map', undefined);
+
+        await import('../src/env.js');
+
+        const map = new globalThis.Map<string, number>();
+        map.set('x', 10);
+        map.set('y', 20);
+        expect(map.delete('x')).toBe(true);
+        expect(map.delete('x')).toBe(false);
+        expect(map.size).toBe(1);
+
+        map.clear();
+        expect(map.size).toBe(0);
+    });
+
+    it('should support iteration', async () => {
+        vi.stubGlobal('Map', undefined);
+
+        await import('../src/env.js');
+
+        const map = new globalThis.Map<string, number>([
+            ['a', 1],
+            ['b', 2],
+        ]);
+
+        const keys = [...map.keys()];
+        const values = [...map.values()];
+        const entries = [...map.entries()];
+
+        expect(keys).toEqual(['a', 'b']);
+        expect(values).toEqual([1, 2]);
+        expect(entries).toEqual([
+            ['a', 1],
+            ['b', 2],
+        ]);
+    });
+
+    it('should support forEach', async () => {
+        vi.stubGlobal('Map', undefined);
+
+        await import('../src/env.js');
+
+        const map = new globalThis.Map([['k', 'v']]);
+        const collected: string[] = [];
+        map.forEach((val, key) => collected.push(`${key}=${val}`));
+        expect(collected).toEqual(['k=v']);
+    });
+
+    it('should overwrite existing keys', async () => {
+        vi.stubGlobal('Map', undefined);
+
+        await import('../src/env.js');
+
+        const map = new globalThis.Map<string, number>();
+        map.set('a', 1);
+        map.set('a', 2);
+        expect(map.size).toBe(1);
+        expect(map.get('a')).toBe(2);
+    });
+
+    it('should not replace native Map', async () => {
+        const NativeMap = globalThis.Map;
+
+        await import('../src/env.js');
+
+        expect(globalThis.Map).toBe(NativeMap);
+    });
+});
+
+describe('Polyfill — Promise.allSettled', () => {
+    beforeEach(() => {
+        vi.resetModules();
+    });
+
+    afterEach(() => {
+        vi.unstubAllGlobals();
+        vi.restoreAllMocks();
+    });
+
+    it('should polyfill Promise.allSettled when missing', async () => {
+        const orig = Promise.allSettled;
+        (Promise as Record<string, unknown>)['allSettled'] = undefined;
+
+        try {
+            await import('../src/env.js');
+
+            const results = await Promise.allSettled([
+                Promise.resolve(1),
+                Promise.reject(new Error('fail')),
+                Promise.resolve(3),
+            ]);
+
+            expect(results).toHaveLength(3);
+            expect(results[0]).toEqual({ status: 'fulfilled', value: 1 });
+            expect(results[1]!.status).toBe('rejected');
+            expect((results[1] as PromiseRejectedResult).reason).toBeInstanceOf(Error);
+            expect(results[2]).toEqual({ status: 'fulfilled', value: 3 });
+        } finally {
+            Promise.allSettled = orig;
+        }
+    });
+
+    it('should not replace native Promise.allSettled', async () => {
+        const native = Promise.allSettled;
+
+        await import('../src/env.js');
+
+        expect(Promise.allSettled).toBe(native);
+    });
+});
+
+describe('Polyfill — structuredClone', () => {
+    beforeEach(() => {
+        vi.resetModules();
+    });
+
+    afterEach(() => {
+        vi.unstubAllGlobals();
+        vi.restoreAllMocks();
+    });
+
+    it('should polyfill structuredClone when missing', async () => {
+        vi.stubGlobal('structuredClone', undefined);
+
+        await import('../src/env.js');
+
+        const original = { a: 1, b: { c: 2 } };
+        const cloned = globalThis.structuredClone(original);
+
+        expect(cloned).toEqual(original);
+        expect(cloned).not.toBe(original);
+        expect(cloned.b).not.toBe(original.b);
+    });
+
+    it('should deep clone nested objects', async () => {
+        vi.stubGlobal('structuredClone', undefined);
+
+        await import('../src/env.js');
+
+        const original = { x: [1, 2, { y: 3 }] };
+        const cloned = globalThis.structuredClone(original);
+
+        cloned.x[0] = 99;
+        (cloned.x[2] as { y: number }).y = 99;
+
+        expect(original.x[0]).toBe(1);
+        expect((original.x[2] as { y: number }).y).toBe(3);
+    });
+
+    it('should handle primitives and null', async () => {
+        vi.stubGlobal('structuredClone', undefined);
+
+        await import('../src/env.js');
+
+        expect(globalThis.structuredClone(42)).toBe(42);
+        expect(globalThis.structuredClone('hello')).toBe('hello');
+        expect(globalThis.structuredClone(true)).toBe(true);
+        expect(globalThis.structuredClone(null)).toBe(null);
+    });
+
+    it('should not replace native structuredClone', async () => {
+        const native = globalThis.structuredClone;
+
+        await import('../src/env.js');
+
+        expect(globalThis.structuredClone).toBe(native);
+    });
+});
+
+describe('Polyfill — Symbol.dispose / Symbol.asyncDispose', () => {
+    beforeEach(() => {
+        vi.resetModules();
+    });
+
+    afterEach(() => {
+        vi.unstubAllGlobals();
+        vi.restoreAllMocks();
+    });
+
+    it('should ensure Symbol.dispose is defined after import', async () => {
+        await import('../src/env.js');
+        expect(typeof Symbol.dispose).toBe('symbol');
+    });
+
+    it('should ensure Symbol.asyncDispose is defined after import', async () => {
+        await import('../src/env.js');
+        expect(typeof Symbol.asyncDispose).toBe('symbol');
+    });
+
+    it('should polyfill dispose on a target that lacks it', () => {
+        const target: Record<string, symbol | undefined> = { dispose: undefined };
+        if (typeof target['dispose'] === 'undefined') {
+            target['dispose'] = Symbol.for('Symbol.dispose');
+        }
+        expect(target['dispose']).toBe(Symbol.for('Symbol.dispose'));
+    });
+
+    it('should polyfill asyncDispose on a target that lacks it', () => {
+        const target: Record<string, symbol | undefined> = { asyncDispose: undefined };
+        if (typeof target['asyncDispose'] === 'undefined') {
+            target['asyncDispose'] = Symbol.for('Symbol.asyncDispose');
+        }
+        expect(target['asyncDispose']).toBe(Symbol.for('Symbol.asyncDispose'));
+    });
+
+    it('should not overwrite an existing dispose symbol', () => {
+        const existing = Symbol('existing');
+        const target: Record<string, symbol> = { dispose: existing };
+        if (typeof target['dispose'] === 'undefined') {
+            target['dispose'] = Symbol.for('Symbol.dispose');
+        }
+        expect(target['dispose']).toBe(existing);
+    });
+
+    it('should not overwrite an existing asyncDispose symbol', () => {
+        const existing = Symbol('existing');
+        const target: Record<string, symbol> = { asyncDispose: existing };
+        if (typeof target['asyncDispose'] === 'undefined') {
+            target['asyncDispose'] = Symbol.for('Symbol.asyncDispose');
+        }
+        expect(target['asyncDispose']).toBe(existing);
+    });
+
+    it('should produce a usable symbol for async method dispatch', async () => {
+        const sym = Symbol.for('Symbol.asyncDispose');
+        const obj = {
+            disposed: false,
+            async [sym]() {
+                this.disposed = true;
+            },
+        };
+
+        await obj[sym]();
+        expect(obj.disposed).toBe(true);
+    });
+});