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

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));
     }
 
     /**

package/src/types.ts

@@ -3,7 +3,19 @@
  *
  * @packageDocumentation
  */
-import { isZero, compare, fromHex, equals } from './io/index.js';
+import { compare, equals, fromHex, isZero } from './io/index.js';
+import type {
+    Bytes20,
+    Bytes32,
+    MessageHash,
+    PrivateKey,
+    PublicKey,
+    Satoshi,
+    SchnorrSignature,
+    Script,
+    Signature,
+    XOnlyPublicKey,
+} from './branded.js';
 
 // ============================================================================
 // Branded Types (re-exported from branded.ts to avoid circular dependencies)
@@ -18,11 +30,10 @@ 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
 // ============================================================================
@@ -40,20 +51,12 @@ export const TAPLEAF_VERSION_MASK = 0xfe;
 // ============================================================================
 
 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
     );
 }
 
@@ -205,6 +208,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`);
@@ -244,10 +258,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.
      */

package/src/workers/WorkerSigningPool.ts

@@ -31,22 +31,18 @@
  */
 
 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';
 import { createWorkerBlobUrl, revokeWorkerBlobUrl } from './signing-worker.js';
 
 /**
@@ -151,34 +147,6 @@ export class WorkerSigningPool {
         this.#preserveWorkers = this.#config.preserveWorkers;
     }
 
-    /**
-     * Gets the singleton pool instance.
-     *
-     * @param config - Optional configuration (only used on first call)
-     * @returns The singleton pool instance
-     *
-     * @example
-     * ```typescript
-     * const pool = WorkerSigningPool.getInstance({ workerCount: 8 });
-     * ```
-     */
-    public static getInstance(config?: WorkerPoolConfig): WorkerSigningPool {
-        if (!WorkerSigningPool.#instance) {
-            WorkerSigningPool.#instance = new WorkerSigningPool(config);
-        }
-        return WorkerSigningPool.#instance;
-    }
-
-    /**
-     * Resets the singleton instance (for testing).
-     */
-    public static resetInstance(): void {
-        if (WorkerSigningPool.#instance) {
-            WorkerSigningPool.#instance.shutdown().catch(() => {});
-            WorkerSigningPool.#instance = null;
-        }
-    }
-
     /**
      * Number of workers in the pool.
      */
@@ -207,6 +175,34 @@ export class WorkerSigningPool {
         return this.#preserveWorkers;
     }
 
+    /**
+     * Gets the singleton pool instance.
+     *
+     * @param config - Optional configuration (only used on first call)
+     * @returns The singleton pool instance
+     *
+     * @example
+     * ```typescript
+     * const pool = WorkerSigningPool.getInstance({ workerCount: 8 });
+     * ```
+     */
+    public static getInstance(config?: WorkerPoolConfig): WorkerSigningPool {
+        if (!WorkerSigningPool.#instance) {
+            WorkerSigningPool.#instance = new WorkerSigningPool(config);
+        }
+        return WorkerSigningPool.#instance;
+    }
+
+    /**
+     * Resets the singleton instance (for testing).
+     */
+    public static resetInstance(): void {
+        if (WorkerSigningPool.#instance) {
+            WorkerSigningPool.#instance.shutdown().catch(() => {});
+            WorkerSigningPool.#instance = null;
+        }
+    }
+
     /**
      * Enables worker preservation between signing batches.
      *

package/src/workers/index.node.ts

@@ -0,0 +1,27 @@
+/**
+ * Node.js worker pool entry point.
+ *
+ * This module provides direct access to Node.js-specific worker functionality.
+ * It re-exports everything from the base index plus Node.js specific exports.
+ *
+ * @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
+ */
+
+// Re-export everything from browser-safe index
+export * from './index.js';
+
+// Node.js specific exports
+export { NodeWorkerSigningPool, type NodeWorkerPoolConfig } from './WorkerSigningPool.node.js';

package/src/workers/index.ts

@@ -46,6 +46,8 @@
  * @packageDocumentation
  */
 
+import type { WorkerPoolConfig, SigningTask, ParallelSignerKeyPair, ParallelSigningResult } from './types.js';
+
 // Type exports
 export {
     SignatureType,
@@ -85,9 +87,6 @@ export { generateWorkerCode, createWorkerBlobUrl, revokeWorkerBlobUrl } from './
 // 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,
@@ -133,11 +132,11 @@ export function detectRuntime(): 'node' | 'browser' | 'unknown' {
  * await pool.shutdown();
  * ```
  */
-export async function createSigningPool(config?: import('./types.js').WorkerPoolConfig): Promise<{
+export async function createSigningPool(config?: WorkerPoolConfig): Promise<{
     signBatch: (
-        tasks: readonly import('./types.js').SigningTask[],
-        keyPair: import('./types.js').ParallelSignerKeyPair,
-    ) => Promise<import('./types.js').ParallelSigningResult>;
+        tasks: readonly SigningTask[],
+        keyPair: ParallelSignerKeyPair,
+    ) => Promise<ParallelSigningResult>;
     preserveWorkers: () => void;
     releaseWorkers: () => void;
     shutdown: () => Promise<void>;
@@ -149,7 +148,6 @@ export async function createSigningPool(config?: import('./types.js').WorkerPool
     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();
@@ -162,4 +160,4 @@ export async function createSigningPool(config?: import('./types.js').WorkerPool
     } else {
         throw new Error('Unsupported runtime for worker signing pool');
     }
-}
+}

package/src/workers/psbt-parallel.ts

@@ -28,16 +28,11 @@
  * @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, SigningTask, WorkerPoolConfig, } from './types.js';
 import { SignatureType } from './types.js';
 import { WorkerSigningPool } from './WorkerSigningPool.js';
 import { toXOnly } from '../pubkey.js';

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.

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,
+                );
             });
         });
     });