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

package/src/workers/index.node.ts

@@ -0,0 +1,50 @@
+/**
+ * Node.js worker pool entry point.
+ *
+ * Uses worker_threads for parallel signing. Provides direct access to
+ * NodeWorkerSigningPool without runtime detection overhead.
+ *
+ * @example
+ * ```typescript
+ * import { NodeWorkerSigningPool } from '@btc-vision/bitcoin/workers';
+ *
+ * const pool = NodeWorkerSigningPool.getInstance({ workerCount: 4 });
+ * await pool.initialize();
+ * pool.preserveWorkers();
+ *
+ * const result = await pool.signBatch(tasks, keyPair);
+ *
+ * await pool.shutdown();
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+import type { WorkerPoolConfig, SigningPoolLike } from './types.js';
+
+export * from './index.shared.js';
+
+// Node.js specific exports
+export { NodeWorkerSigningPool, type NodeWorkerPoolConfig } from './WorkerSigningPool.node.js';
+
+/**
+ * Detects the runtime environment.
+ *
+ * @returns Always 'node' in this entry point.
+ */
+export function detectRuntime(): 'node' | 'browser' | 'react-native' | 'unknown' {
+    return 'node';
+}
+
+/**
+ * Creates a signing pool for the Node.js runtime using worker_threads.
+ *
+ * @param config - Optional pool configuration
+ * @returns A promise resolving to the initialized signing pool
+ */
+export async function createSigningPool(config?: WorkerPoolConfig): Promise<SigningPoolLike> {
+    const { NodeWorkerSigningPool } = await import('./WorkerSigningPool.node.js');
+    const pool = NodeWorkerSigningPool.getInstance(config);
+    await pool.initialize();
+    return pool;
+}

package/src/workers/index.react-native.ts

@@ -0,0 +1,110 @@
+/**
+ * React Native entry point for the workers module.
+ *
+ * Provides the same public API as the browser/Node.js workers module
+ * but uses WorkletSigningPool (parallel via react-native-worklets)
+ * when available, falling back to SequentialSigningPool (main-thread).
+ *
+ * @packageDocumentation
+ */
+
+// Type exports (same as main index.ts)
+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';
+
+// Sequential pool (React Native fallback)
+export { SequentialSigningPool } from './WorkerSigningPool.sequential.js';
+
+// Worklet pool (React Native parallel signing)
+export { WorkletSigningPool } from './WorkerSigningPool.worklet.js';
+
+// Alias for API compatibility — consumers using `WorkerSigningPool` get the sequential pool
+export { SequentialSigningPool as WorkerSigningPool } from './WorkerSigningPool.sequential.js';
+
+// PSBT parallel signing integration (works with any SigningPoolLike)
+export {
+    signPsbtParallel,
+    prepareSigningTasks,
+    applySignaturesToPsbt,
+    type ParallelSignOptions,
+    type PsbtParallelKeyPair,
+} from './psbt-parallel.js';
+
+/**
+ * Detects the runtime environment.
+ *
+ * @returns Always 'react-native' in this entry point.
+ */
+export function detectRuntime(): 'node' | 'browser' | 'react-native' | 'unknown' {
+    return 'react-native';
+}
+
+/**
+ * Cached result of the worklets availability check.
+ * `null` = not yet checked, `true` = available, `false` = unavailable.
+ */
+let workletsAvailable: boolean | null = null;
+
+/**
+ * Creates a signing pool appropriate for the React Native runtime.
+ *
+ * Tries to use WorkletSigningPool (parallel via react-native-worklets).
+ * Falls back to SequentialSigningPool if worklets are not installed.
+ */
+export async function createSigningPool(
+    config?: import('./types.js').WorkerPoolConfig,
+): Promise<import('./types.js').SigningPoolLike> {
+    // Check worklets availability (cached after first probe)
+    if (workletsAvailable === null) {
+        try {
+            await import('react-native-worklets' as string);
+            workletsAvailable = true;
+        } catch {
+            workletsAvailable = false;
+        }
+    }
+
+    if (workletsAvailable) {
+        try {
+            const { WorkletSigningPool } = await import('./WorkerSigningPool.worklet.js');
+            const pool = WorkletSigningPool.getInstance(config);
+            await pool.initialize();
+            return pool;
+        } catch {
+            // Initialization failed (e.g. eval blocked) — fall through
+            workletsAvailable = false;
+        }
+    }
+
+    const { SequentialSigningPool } = await import('./WorkerSigningPool.sequential.js');
+    const pool = SequentialSigningPool.getInstance(config);
+    await pool.initialize();
+    return pool;
+}

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,63 +47,19 @@
  * @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,
-    WorkerState,
-    type PooledWorker,
-} from './types.js';
+import type { WorkerPoolConfig, SigningPoolLike } 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';
-
-// Node.js specific exports (use dynamic import in browser builds)
-export { type NodeWorkerPoolConfig } from './WorkerSigningPool.node.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 as {product?: string}).product === 'ReactNative') {
+        return 'react-native';
+    }
     if (typeof process !== 'undefined' && process.versions?.node) {
         return 'node';
     }
@@ -133,23 +90,10 @@ export function detectRuntime(): 'node' | 'browser' | 'unknown' {
  * await pool.shutdown();
  * ```
  */
-export async 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;
-}> {
+export async function createSigningPool(config?: WorkerPoolConfig): Promise<SigningPoolLike> {
     const runtime = detectRuntime();
 
     if (runtime === 'node') {
-        // Dynamic import for Node.js to avoid bundler issues
         const { NodeWorkerSigningPool } = await import('./WorkerSigningPool.node.js');
         const pool = NodeWorkerSigningPool.getInstance(config);
         await pool.initialize();
@@ -159,6 +103,11 @@ export async function createSigningPool(config?: import('./types.js').WorkerPool
         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

@@ -28,18 +28,12 @@
  * @packageDocumentation
  */
 
-import type { PsbtInput, TapScriptSig, TapKeySig } from 'bip174';
+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 {
-    SigningTask,
-    ParallelSignerKeyPair,
-    ParallelSigningResult,
-    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';
@@ -113,16 +107,17 @@ 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 {
+        const { WorkerSigningPool } = await import('./WorkerSigningPool.js');
         pool = WorkerSigningPool.getInstance(poolOrConfig);
         if (!pool.isPreservingWorkers) {
             shouldShutdown = true;
@@ -315,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

@@ -153,7 +153,11 @@ export interface BatchSigningResultMessage {
 /**
  * All possible messages to worker.
  */
-export type WorkerMessage = SigningTaskMessage | BatchSigningMessage | WorkerInitMessage | WorkerShutdownMessage;
+export type WorkerMessage =
+    | SigningTaskMessage
+    | BatchSigningMessage
+    | WorkerInitMessage
+    | WorkerShutdownMessage;
 
 /**
  * Result from worker after signing.
@@ -396,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 extends Disposable, AsyncDisposable {
+    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/address.spec.ts

@@ -6,11 +6,11 @@ import { fromBech32 } from '../src/bech32utils.js';
 import * as bscript from '../src/script.js';
 import fixtures from './fixtures/address.json' with { type: 'json' };
 
-import { initEccLib } from '../src/index.js';
 import type { EccLib } from '../src/index.js';
+import { initEccLib } from '../src/index.js';
 import type { Network } from '../src/networks.js';
 import * as networks from '../src/networks.js';
-import { toHex, fromHex } from '../src/io/index.js';
+import { fromHex, toHex } from '../src/io/index.js';
 import type { Bytes20 } from '../src/types.js';
 
 const NETWORKS: Record<string, Network> = Object.assign(

package/test/bitcoin.core.spec.ts

@@ -3,7 +3,7 @@ import base58 from 'bs58';
 import { describe, it } from 'vitest';
 import * as bitcoin from '../src/index.js';
 import type { Bytes20, Satoshi, Script } from '../src/types.js';
-import { toHex, fromHex, reverseCopy } from '../src/io/index.js';
+import { fromHex, reverseCopy, toHex } from '../src/io/index.js';
 import base58EncodeDecode from './fixtures/core/base58_encode_decode.json' with { type: 'json' };
 import base58KeysInvalid from './fixtures/core/base58_keys_invalid.json' with { type: 'json' };
 import base58KeysValid from './fixtures/core/base58_keys_valid.json' with { type: 'json' };
@@ -57,7 +57,10 @@ describe('Bitcoin-core', () => {
             const version = network[typeMap[params.addrType]];
 
             it(`can export ${expected as string}`, () => {
-                assert.strictEqual(bitcoin.address.toBase58Check(hash as Bytes20, version), expected);
+                assert.strictEqual(
+                    bitcoin.address.toBase58Check(hash as Bytes20, version),
+                    expected,
+                );
             });
         });
     });

package/test/browser/payments.spec.ts

@@ -0,0 +1,151 @@
+/**
+ * Browser-adapted version of test/payments.spec.ts
+ * Replaces fs.readFileSync with static JSON imports.
+ */
+import assert from 'assert';
+import * as ecc from 'tiny-secp256k1';
+import { beforeEach, describe, it } from 'vitest';
+import type { EccLib } from '../../src/index.js';
+import { initEccLib } from '../../src/index.js';
+import type { P2SHPayment, PaymentCreator } from '../../src/payments/index.js';
+import { p2pk, p2wsh } from '../../src/payments/index.js';
+import * as u from '../payments.utils.js';
+import { fromHex } from '../../src/io/index.js';
+import type { PublicKey } from '../../src/types.js';
+
+// Pre-load all payment modules synchronously-like at import time
+import * as embedModule from '../../src/payments/embed.js';
+import * as p2msModule from '../../src/payments/p2ms.js';
+import * as p2pkModule from '../../src/payments/p2pk.js';
+import * as p2pkhModule from '../../src/payments/p2pkh.js';
+import * as p2shModule from '../../src/payments/p2sh.js';
+import * as p2wpkhModule from '../../src/payments/p2wpkh.js';
+import * as p2wshModule from '../../src/payments/p2wsh.js';
+import * as p2trModule from '../../src/payments/p2tr.js';
+
+// Static JSON imports instead of fs.readFileSync
+import embedFixtures from '../fixtures/embed.json' with { type: 'json' };
+import p2msFixtures from '../fixtures/p2ms.json' with { type: 'json' };
+import p2pkFixtures from '../fixtures/p2pk.json' with { type: 'json' };
+import p2pkhFixtures from '../fixtures/p2pkh.json' with { type: 'json' };
+import p2shFixtures from '../fixtures/p2sh.json' with { type: 'json' };
+import p2wpkhFixtures from '../fixtures/p2wpkh.json' with { type: 'json' };
+import p2wshFixtures from '../fixtures/p2wsh.json' with { type: 'json' };
+import p2trFixtures from '../fixtures/p2tr.json' with { type: 'json' };
+
+const fixtureMap: Record<string, any> = {
+    embed: embedFixtures,
+    p2ms: p2msFixtures,
+    p2pk: p2pkFixtures,
+    p2pkh: p2pkhFixtures,
+    p2sh: p2shFixtures,
+    p2wpkh: p2wpkhFixtures,
+    p2wsh: p2wshFixtures,
+    p2tr: p2trFixtures,
+};
+
+const paymentModules: Record<string, { [key: string]: PaymentCreator }> = {
+    embed: embedModule as any,
+    p2ms: p2msModule as any,
+    p2pk: p2pkModule as any,
+    p2pkh: p2pkhModule as any,
+    p2sh: p2shModule as any,
+    p2wpkh: p2wpkhModule as any,
+    p2wsh: p2wshModule as any,
+    p2tr: p2trModule as any,
+};
+
+// Initialize ECC library at module load time
+initEccLib(ecc as unknown as EccLib);
+
+['embed', 'p2ms', 'p2pk', 'p2pkh', 'p2sh', 'p2wpkh', 'p2wsh', 'p2tr'].forEach((p) => {
+    describe(p, () => {
+        // Ensure ECC library is initialized before each test
+        beforeEach(() => {
+            initEccLib(ecc as unknown as EccLib);
+        });
+
+        const payment = paymentModules[p]!;
+        let fn: PaymentCreator;
+        if (p === 'embed') {
+            fn = payment['p2data']!;
+        } else {
+            fn = payment[p]!;
+        }
+
+        const fixtures = fixtureMap[p];
+        fixtures.valid.forEach((f: any) => {
+            it(f.description + ' as expected', () => {
+                const args = u.preform(f.arguments);
+                const actual = fn(args, f.options);
+
+                u.equate(actual, f.expected, f.arguments);
+            });
+
+            it(f.description + ' as expected (no validation)', () => {
+                const args = u.preform(f.arguments);
+                const actual = fn(
+                    args,
+                    Object.assign({}, f.options, {
+                        validate: false,
+                    }),
+                );
+
+                u.equate(actual, f.expected, f.arguments);
+            });
+        });
+
+        if (p === 'p2sh') {
+            it('properly assembles nested p2wsh with names', () => {
+                const actual = fn({
+                    redeem: p2wsh({
+                        redeem: p2pk({
+                            pubkey: fromHex(
+                                '03e15819590382a9dd878f01e2f0cbce541564eb415e43b440472d883ecd283058',
+                            ) as PublicKey,
+                        }),
+                    }),
+                } as P2SHPayment);
+                assert.strictEqual(actual.address, '3MGbrbye4ttNUXM8WAvBFRKry4fkS9fjuw');
+                assert.strictEqual(actual.name, 'p2sh-p2wsh-p2pk');
+                assert.strictEqual(actual.redeem!.name, 'p2wsh-p2pk');
+                assert.strictEqual(actual.redeem!.redeem!.name, 'p2pk');
+            });
+        }
+
+        // cross-verify dynamically too
+        if (!fixtures.dynamic) return;
+        const { depends, details } = fixtures.dynamic;
+
+        details.forEach((f: any) => {
+            const detail = u.preform(f);
+            const disabled: any = {};
+            if (f.disabled)
+                f.disabled.forEach((k: string) => {
+                    disabled[k] = true;
+                });
+
+            for (const key in depends) {
+                if (key in disabled) continue;
+                const dependencies = depends[key];
+
+                dependencies.forEach((dependency: any) => {
+                    if (!Array.isArray(dependency)) dependency = [dependency];
+
+                    const args = {};
+                    dependency.forEach((d: any) => {
+                        u.from(d, detail, args);
+                    });
+                    const expected = u.from(key, detail);
+
+                    it(
+                        f.description + ', ' + key + ' derives from ' + JSON.stringify(dependency),
+                        () => {
+                            u.equate(fn(args), expected);
+                        },
+                    );
+                });
+            }
+        });
+    });
+});