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

package/src/script.ts

@@ -3,14 +3,15 @@
  * @packageDocumentation
  */
 import * as bip66 from './bip66.js';
-import { toHex, fromHex, alloc } from './io/index.js';
+import { alloc, fromHex, toHex } from './io/index.js';
 import type { Opcodes } from './opcodes.js';
-import { opcodes, REVERSE_OPS } from './opcodes.js';
+import { getReverseOps, opcodes } from './opcodes.js';
 import * as pushdata from './push_data.js';
 import * as scriptNumber from './script_number.js';
 import * as scriptSignature from './script_signature.js';
-import * as types from './types.js';
+import { isDefinedHashType } from './script_signature.js';
 import type { Script, Stack } from './types.js';
+import * as types from './types.js';
 
 const OP_INT_BASE = opcodes.OP_RESERVED; // OP_1 - 1
 export { opcodes };
@@ -116,9 +117,7 @@ export function compile(chunks: Uint8Array | Stack): Script {
     return buffer as Script;
 }
 
-export function decompile(
-    buffer: Uint8Array | Stack,
-): Array<number | Uint8Array> | null {
+export function decompile(buffer: Uint8Array | Stack): Array<number | Uint8Array> | null {
     // Already decompiled - return as-is
     if (chunksIsArray(buffer)) return buffer as Array<number | Uint8Array>;
 
@@ -192,7 +191,7 @@ export function toASM(chunks: Uint8Array | Stack): string {
             }
 
             // opcode!
-            return REVERSE_OPS[chunk];
+            return getReverseOps()[chunk];
         })
         .join(' ');
 }
@@ -247,8 +246,6 @@ export function isCanonicalPubKey(buffer: Uint8Array): boolean {
     return types.isPoint(buffer);
 }
 
-import { isDefinedHashType } from './script_signature.js';
-
 export function isCanonicalScriptSignature(buffer: Uint8Array): boolean {
     if (!(buffer instanceof Uint8Array)) return false;
     if (!isDefinedHashType(buffer[buffer.length - 1]!)) return false;

package/src/transaction.ts

@@ -1,8 +1,9 @@
-import { BinaryReader, BinaryWriter, reverse, varuint, fromHex, toHex, alloc } from './io/index.js';
+import { alloc, BinaryReader, BinaryWriter, fromHex, reverse, toHex, varuint } from './io/index.js';
 import * as bcrypto from './crypto.js';
 import * as bscript from './script.js';
 import { opcodes } from './script.js';
-import type { Bytes32, Satoshi, Script } from './types.js';
+import type { Bytes32, MessageHash, Satoshi, Script } from './types.js';
+import { toMessageHash } from './types.js';
 
 function varSliceSize(someScript: Uint8Array): number {
     const length = someScript.length;
@@ -23,10 +24,8 @@ function vectorSize(someVector: Uint8Array[]): number {
 
 const EMPTY_BYTES = new Uint8Array(0) as Script;
 const EMPTY_WITNESS: Uint8Array[] = [];
-const ZERO = fromHex(
-    '0000000000000000000000000000000000000000000000000000000000000000',
-) as Bytes32;
-const ONE = fromHex('0000000000000000000000000000000000000000000000000000000000000001') as Bytes32;
+const ZERO = fromHex('0000000000000000000000000000000000000000000000000000000000000000') as Bytes32;
+const ONE: MessageHash = toMessageHash(fromHex('0000000000000000000000000000000000000000000000000000000000000001'));
 
 /** Maximum value for SIGHASH_SINGLE blank outputs (0xFFFFFFFFFFFFFFFF) */
 const BLANK_OUTPUT_VALUE = 0xffffffffffffffffn as Satoshi;
@@ -330,7 +329,7 @@ export class Transaction {
      * @param hashType - Signature hash type
      * @returns 32-byte hash for signing
      */
-    hashForSignature(inIndex: number, prevOutScript: Script, hashType: number): Bytes32 {
+    hashForSignature(inIndex: number, prevOutScript: Script, hashType: number): MessageHash {
         if (!Number.isInteger(inIndex) || inIndex < 0) {
             throw new TypeError('Expected non-negative integer for inIndex');
         }
@@ -410,7 +409,7 @@ export class Transaction {
         writer.writeInt32LE(hashType);
         txTmp.#toBuffer(buffer, 0, false);
 
-        return bcrypto.hash256(buffer) as Bytes32;
+        return toMessageHash(bcrypto.hash256(buffer));
     }
 
     /**
@@ -432,7 +431,7 @@ export class Transaction {
         leafHash?: Bytes32,
         annex?: Uint8Array,
         taprootCache?: TaprootHashCache,
-    ): Bytes32 {
+    ): MessageHash {
         // https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki#common-signature-message
         if (!Number.isInteger(inIndex) || inIndex < 0 || inIndex > 0xffffffff) {
             throw new TypeError('Expected unsigned 32-bit integer for inIndex');
@@ -493,7 +492,9 @@ export class Transaction {
                 bufferWriter = new BinaryWriter(
                     prevOutScripts.map(varSliceSize).reduce((a, b) => a + b),
                 );
-                prevOutScripts.forEach((prevOutScript) => bufferWriter.writeVarBytes(prevOutScript));
+                prevOutScripts.forEach((prevOutScript) =>
+                    bufferWriter.writeVarBytes(prevOutScript),
+                );
                 hashScriptPubKeys = bcrypto.sha256(bufferWriter.finish());
 
                 bufferWriter = new BinaryWriter(4 * this.ins.length);
@@ -589,7 +590,7 @@ export class Transaction {
         const combined = new Uint8Array(1 + sigMsg.length);
         combined.set(prefix);
         combined.set(sigMsg, 1);
-        return bcrypto.taggedHash('TapSighash', combined) as Bytes32;
+        return toMessageHash(bcrypto.taggedHash('TapSighash', combined));
     }
 
     /**
@@ -600,7 +601,10 @@ export class Transaction {
      * @param values - Array of previous output values for all inputs
      * @returns Cache object to pass to hashForWitnessV1
      */
-    getTaprootHashCache(prevOutScripts: readonly Script[], values: readonly Satoshi[]): TaprootHashCache {
+    getTaprootHashCache(
+        prevOutScripts: readonly Script[],
+        values: readonly Satoshi[],
+    ): TaprootHashCache {
         // hashPrevouts
         let bufferWriter = new BinaryWriter(36 * this.ins.length);
         for (const txIn of this.ins) {
@@ -663,7 +667,7 @@ export class Transaction {
         prevOutScript: Script,
         value: Satoshi,
         hashType: number,
-    ): Bytes32 {
+    ): MessageHash {
         if (!Number.isInteger(inIndex) || inIndex < 0 || inIndex > 0xffffffff) {
             throw new TypeError('Expected unsigned 32-bit integer for inIndex');
         }
@@ -754,7 +758,7 @@ export class Transaction {
         bufferWriter.writeBytes(hashOutputs);
         bufferWriter.writeUInt32LE(this.locktime);
         bufferWriter.writeUInt32LE(hashType);
-        return bcrypto.hash256(tbuffer) as Bytes32;
+        return toMessageHash(bcrypto.hash256(tbuffer));
     }
 
     /**
@@ -766,7 +770,7 @@ export class Transaction {
     getHash(forWitness?: boolean): Bytes32 {
         // wtxid for coinbase is always 32 bytes of 0x00
         if (forWitness && this.isCoinbase()) return new Uint8Array(32) as Bytes32;
-        return bcrypto.hash256(this.#toBuffer(undefined, undefined, forWitness)) as Bytes32;
+        return bcrypto.hash256(this.#toBuffer(undefined, undefined, forWitness));
     }
 
     /**

package/src/types.ts

@@ -3,11 +3,19 @@
  *
  * @packageDocumentation
  */
-import { isZero, compare, fromHex, equals } from './io/index.js';
-
-// ============================================================================
-// Branded Types (re-exported from branded.ts to avoid circular dependencies)
-// ============================================================================
+import { compare, equals, fromHex, isZero } from './io/index.js';
+import type {
+    Bytes20,
+    Bytes32,
+    MessageHash,
+    PrivateKey,
+    PublicKey,
+    Satoshi,
+    SchnorrSignature,
+    Script,
+    Signature,
+    XOnlyPublicKey,
+} from './branded.js';
 
 export type {
     Bytes32,
@@ -18,42 +26,26 @@ export type {
     PrivateKey,
     Signature,
     SchnorrSignature,
+    MessageHash,
     Script,
 } from './branded.js';
 
-import type { Bytes32, Bytes20, Satoshi, PrivateKey, XOnlyPublicKey, PublicKey, SchnorrSignature, Signature, 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
-    );
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= 0xff;
 }
 
 export function isUInt32(value: unknown): value is number {
     return (
-        typeof value === 'number' &&
-        Number.isInteger(value) &&
-        value >= 0 &&
-        value <= 0xffffffff
+        typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= 0xffffffff
     );
 }
 
@@ -93,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 {
@@ -127,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 {
@@ -143,9 +133,7 @@ export function isScript(value: unknown): value is Script {
     return value instanceof Uint8Array;
 }
 
-// ============================================================================
 // Taproot Types
-// ============================================================================
 
 export interface Tapleaf {
     readonly output: Uint8Array;
@@ -175,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 { XOnlyPointAddTweakResult, EccLib, Parity } from './ecc/types.js';
+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;
@@ -205,6 +187,17 @@ export function toBytes32(value: Uint8Array): Bytes32 {
     return value;
 }
 
+export function isMessageHash(value: unknown): value is MessageHash {
+    return value instanceof Uint8Array && value.length === 32;
+}
+
+export function toMessageHash(value: Uint8Array): MessageHash {
+    if (!isMessageHash(value)) {
+        throw new TypeError(`Expected 32-byte Uint8Array, got ${value.length} bytes`);
+    }
+    return value;
+}
+
 export function toBytes20(value: Uint8Array): Bytes20 {
     if (!isBytes20(value)) {
         throw new TypeError(`Expected 20-byte Uint8Array, got ${value.length} bytes`);
@@ -222,9 +215,7 @@ export function toSatoshi(value: bigint): Satoshi {
     return value as Satoshi;
 }
 
-// ============================================================================
 // Assertion Helpers
-// ============================================================================
 
 export function assertXOnlyPublicKey(
     value: unknown,
@@ -244,10 +235,7 @@ export function assertXOnlyPublicKey(
     }
 }
 
-export function assertPrivateKey(
-    value: unknown,
-    name: string,
-): asserts value is PrivateKey {
+export function assertPrivateKey(value: unknown, name: string): asserts value is PrivateKey {
     if (!(value instanceof Uint8Array)) {
         throw new TypeError(`${name} must be Uint8Array, got ${typeof value}`);
     }

package/src/workers/WorkerSigningPool.node.ts

@@ -7,21 +7,21 @@
  * @packageDocumentation
  */
 
-import { Worker, isMainThread } from 'worker_threads';
+import { isMainThread, Worker } from 'worker_threads';
 import { cpus } from 'os';
 import type {
-    WorkerPoolConfig,
-    SigningTask,
+    BatchSigningMessage,
+    BatchSigningResultMessage,
+    BatchSigningTask,
     ParallelSignerKeyPair,
     ParallelSigningResult,
+    PooledWorker,
     SigningResultMessage,
+    SigningTask,
+    WorkerPoolConfig,
     WorkerResponse,
-    BatchSigningMessage,
-    BatchSigningTask,
-    BatchSigningResultMessage,
-    PooledWorker,
 } from './types.js';
-import { WorkerState, isBatchResult, isWorkerReady } from './types.js';
+import { isBatchResult, isWorkerReady, WorkerState } from './types.js';
 
 /**
  * ECC library types for Node.js worker.
@@ -163,29 +163,6 @@ export class NodeWorkerSigningPool {
         this.#preserveWorkers = this.#config.preserveWorkers;
     }
 
-    /**
-     * Gets the singleton pool instance.
-     *
-     * @param config - Optional configuration (only used on first call)
-     * @returns The singleton pool instance
-     */
-    public static getInstance(config?: NodeWorkerPoolConfig): NodeWorkerSigningPool {
-        if (!NodeWorkerSigningPool.#instance) {
-            NodeWorkerSigningPool.#instance = new NodeWorkerSigningPool(config);
-        }
-        return NodeWorkerSigningPool.#instance;
-    }
-
-    /**
-     * Resets the singleton instance (for testing).
-     */
-    public static resetInstance(): void {
-        if (NodeWorkerSigningPool.#instance) {
-            NodeWorkerSigningPool.#instance.shutdown().catch(() => {});
-            NodeWorkerSigningPool.#instance = null;
-        }
-    }
-
     /**
      * Number of workers in the pool.
      */
@@ -214,6 +191,29 @@ export class NodeWorkerSigningPool {
         return this.#preserveWorkers;
     }
 
+    /**
+     * Gets the singleton pool instance.
+     *
+     * @param config - Optional configuration (only used on first call)
+     * @returns The singleton pool instance
+     */
+    public static getInstance(config?: NodeWorkerPoolConfig): NodeWorkerSigningPool {
+        if (!NodeWorkerSigningPool.#instance) {
+            NodeWorkerSigningPool.#instance = new NodeWorkerSigningPool(config);
+        }
+        return NodeWorkerSigningPool.#instance;
+    }
+
+    /**
+     * Resets the singleton instance (for testing).
+     */
+    public static resetInstance(): void {
+        if (NodeWorkerSigningPool.#instance) {
+            NodeWorkerSigningPool.#instance.shutdown().catch(() => {});
+            NodeWorkerSigningPool.#instance = null;
+        }
+    }
+
     /**
      * Enables worker preservation between signing batches.
      */
@@ -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.
      *
@@ -378,13 +387,17 @@ export class NodeWorkerSigningPool {
         this.#shuttingDown = false;
     }
 
+    public [Symbol.dispose](): void {
+        void this.shutdown();
+    }
+
     /**
      * Creates the inline worker script for Node.js worker_threads.
      * Supports both @noble/secp256k1 (pure JS) and tiny-secp256k1 (WASM).
      */
     #createWorkerScript(): string {
         // Node.js worker_threads can directly require/import modules
-        const workerCode = `
+        return `
 const { parentPort } = require('worker_threads');
 
 /**
@@ -649,7 +662,6 @@ function handleSignBatch(msg) {
     });
 }
 `;
-        return workerCode;
     }
 
     /**
@@ -772,16 +784,40 @@ function handleSignBatch(msg) {
                 leafHash: task.leafHash,
             }));
 
+            // Copy private key for this worker (original shared across workers)
+            const workerPrivateKey = new Uint8Array(privateKey);
+
             // Create batch message
             const message: BatchSigningMessage = {
                 type: 'signBatch',
                 batchId,
                 tasks: batchTasks,
-                privateKey,
+                privateKey: workerPrivateKey,
             };
 
-            // Send to worker
-            worker.worker.postMessage(message);
+            // Collect ArrayBuffers for zero-copy transfer.
+            // Only transfer buffers unique to this worker batch — NOT publicKey
+            // (shared across all worker batches, would detach for other workers).
+            const keyBuf = workerPrivateKey.buffer as ArrayBuffer;
+            const transferList: ArrayBuffer[] = [keyBuf];
+            const seen = new Set<ArrayBuffer>([keyBuf]);
+            for (const task of batchTasks) {
+                const hashBuf = task.hash.buffer as ArrayBuffer;
+                if (!seen.has(hashBuf)) {
+                    seen.add(hashBuf);
+                    transferList.push(hashBuf);
+                }
+                if (task.leafHash) {
+                    const leafBuf = task.leafHash.buffer as ArrayBuffer;
+                    if (!seen.has(leafBuf)) {
+                        seen.add(leafBuf);
+                        transferList.push(leafBuf);
+                    }
+                }
+            }
+
+            // Send to worker with transfer list (zero-copy)
+            worker.worker.postMessage(message, transferList);
         });
     }
 

package/src/workers/WorkerSigningPool.sequential.ts

@@ -0,0 +1,191 @@
+/**
+ * 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
+    }
+
+    public [Symbol.dispose](): void {
+        void this.shutdown();
+    }
+
+    public async [Symbol.asyncDispose](): Promise<void> {
+        await this.shutdown();
+    }
+}