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

package/src/script.ts

@@ -5,7 +5,7 @@
 import * as bip66 from './bip66.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';
@@ -191,7 +191,7 @@ export function toASM(chunks: Uint8Array | Stack): string {
             }
 
             // opcode!
-            return REVERSE_OPS[chunk];
+            return getReverseOps()[chunk];
         })
         .join(' ');
 }

package/src/transaction.ts

@@ -2,7 +2,8 @@ import { alloc, BinaryReader, BinaryWriter, fromHex, reverse, toHex, varuint } f
 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;
@@ -24,7 +25,7 @@ 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 ONE: MessageHash = toMessageHash(fromHex('0000000000000000000000000000000000000000000000000000000000000001'));
 
 /** Maximum value for SIGHASH_SINGLE blank outputs (0xFFFFFFFFFFFFFFFF) */
 const BLANK_OUTPUT_VALUE = 0xffffffffffffffffn as Satoshi;
@@ -328,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');
         }
@@ -408,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));
     }
 
     /**
@@ -430,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');
@@ -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));
     }
 
     /**
@@ -666,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');
         }
@@ -757,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));
     }
 
     /**
@@ -769,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

@@ -7,6 +7,7 @@ import { compare, equals, fromHex, isZero } from './io/index.js';
 import type {
     Bytes20,
     Bytes32,
+    MessageHash,
     PrivateKey,
     PublicKey,
     Satoshi,
@@ -16,10 +17,6 @@ import type {
     XOnlyPublicKey,
 } from './branded.js';
 
-// ============================================================================
-// Branded Types (re-exported from branded.ts to avoid circular dependencies)
-// ============================================================================
-
 export type {
     Bytes32,
     Bytes20,
@@ -29,25 +26,19 @@ export type {
     PrivateKey,
     Signature,
     SchnorrSignature,
+    MessageHash,
     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;
 }
@@ -94,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 {
@@ -128,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 {
@@ -144,9 +133,7 @@ export function isScript(value: unknown): value is Script {
     return value instanceof Uint8Array;
 }
 
-// ============================================================================
 // Taproot Types
-// ============================================================================
 
 export interface Tapleaf {
     readonly output: Uint8Array;
@@ -176,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;
@@ -206,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`);
@@ -223,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.
      *
@@ -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();
+    }
+}

package/src/workers/WorkerSigningPool.ts

@@ -42,7 +42,7 @@ import type {
     WorkerPoolConfig,
     WorkerResponse,
 } from './types.js';
-import { isBatchResult, isWorkerReady, WorkerState, } from './types.js';
+import { isBatchResult, isWorkerReady, WorkerState } from './types.js';
 import { createWorkerBlobUrl, revokeWorkerBlobUrl } from './signing-worker.js';
 
 /**
@@ -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.
      *
@@ -422,6 +431,10 @@ export class WorkerSigningPool {
         this.#shuttingDown = false;
     }
 
+    public [Symbol.dispose](): void {
+        void this.shutdown();
+    }
+
     /**
      * Creates a new worker and adds it to the pool.
      */