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

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

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,
@@ -29,6 +30,7 @@ export type {
     PrivateKey,
     Signature,
     SchnorrSignature,
+    MessageHash,
     Script,
 } from './branded.js';
 
@@ -206,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`);

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';
 
 /**

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