@btc-vision/bitcoin 6.5.1 → 6.5.2

package/src/transaction.ts

@@ -34,13 +34,13 @@ const ONE: Buffer = Buffer.from(
     'hex',
 );
 const VALUE_UINT64_MAX: Buffer = Buffer.from('ffffffffffffffff', 'hex');
-const BLANK_OUTPUT = {
+const BLANK_OUTPUT: BlankOutput = {
     script: EMPTY_BUFFER,
     valueBuffer: VALUE_UINT64_MAX,
 };
 
-function isOutput(out: Output): boolean {
-    return out.value !== undefined;
+function isOutput(out: Output | BlankOutput): out is Output {
+    return 'value' in out;
 }
 
 export interface Output {
@@ -48,6 +48,11 @@ export interface Output {
     value: number;
 }
 
+interface BlankOutput {
+    script: Buffer;
+    valueBuffer: Buffer;
+}
+
 export interface Input {
     hash: Buffer;
     index: number;
@@ -164,7 +169,7 @@ export class Transaction {
                 types.maybe(types.UInt32),
                 types.maybe(types.Buffer),
             ),
-            arguments,
+            [hash, index, sequence, scriptSig],
         );
 
         if (types.Null(sequence)) {
@@ -184,7 +189,7 @@ export class Transaction {
     }
 
     addOutput(scriptPubKey: Buffer, value: number): number {
-        typeforce(types.tuple(types.Buffer, types.Satoshi), arguments);
+        typeforce(types.tuple(types.Buffer, types.Satoshi), [scriptPubKey, value]);
 
         // Add the output and return the output's index
         return (
@@ -266,17 +271,20 @@ export class Transaction {
      * This hash can then be used to sign the provided transaction input.
      */
     hashForSignature(inIndex: number, prevOutScript: Buffer, hashType: number): Buffer {
-        typeforce(
-            types.tuple(types.UInt32, types.Buffer, /* types.UInt8 */ types.Number),
-            arguments,
-        );
+        typeforce(types.tuple(types.UInt32, types.Buffer, /* types.UInt8 */ types.Number), [
+            inIndex,
+            prevOutScript,
+            hashType,
+        ]);
 
         // https://github.com/bitcoin/bitcoin/blob/master/src/test/sighash_tests.cpp#L29
         if (inIndex >= this.ins.length) return ONE;
 
         // ignore OP_CODESEPARATOR
+        const decompiled = bscript.decompile(prevOutScript);
+        if (!decompiled) throw new Error('Could not decompile prevOutScript');
         const ourScript = bscript.compile(
-            bscript.decompile(prevOutScript)!.filter((x) => {
+            decompiled.filter((x) => {
                 return x !== opcodes.OP_CODESEPARATOR;
             }),
         );
@@ -304,7 +312,7 @@ export class Transaction {
 
             // "blank" outputs before
             for (let i = 0; i < inIndex; i++) {
-                (txTmp.outs as any)[i] = BLANK_OUTPUT;
+                (txTmp.outs as (Output | BlankOutput)[])[i] = BLANK_OUTPUT;
             }
 
             // ignore sequence numbers (except at inIndex)
@@ -353,7 +361,7 @@ export class Transaction {
                 typeforce.arrayOf(types.Satoshi),
                 types.UInt32,
             ),
-            arguments,
+            [inIndex, prevOutScripts, values, hashType],
         );
 
         if (values.length !== this.ins.length || prevOutScripts.length !== this.ins.length) {
@@ -490,7 +498,12 @@ export class Transaction {
         value: number,
         hashType: number,
     ): Buffer {
-        typeforce(types.tuple(types.UInt32, types.Buffer, types.Satoshi, types.UInt32), arguments);
+        typeforce(types.tuple(types.UInt32, types.Buffer, types.Satoshi, types.UInt32), [
+            inIndex,
+            prevOutScript,
+            value,
+            hashType,
+        ]);
 
         let tbuffer: Buffer = Buffer.from([]);
         let bufferWriter: BufferWriter;
@@ -592,13 +605,13 @@ export class Transaction {
     }
 
     setInputScript(index: number, scriptSig: Buffer): void {
-        typeforce(types.tuple(types.Number, types.Buffer), arguments);
+        typeforce(types.tuple(types.Number, types.Buffer), [index, scriptSig]);
 
         this.ins[index].script = scriptSig;
     }
 
     setWitness(index: number, witness: Buffer[]): void {
-        typeforce(types.tuple(types.Number, [types.Buffer]), arguments);
+        typeforce(types.tuple(types.Number, [types.Buffer]), [index, witness]);
 
         this.ins[index].witness = witness;
     }
@@ -631,11 +644,11 @@ export class Transaction {
         });
 
         bufferWriter.writeVarInt(this.outs.length);
-        this.outs.forEach((txOut) => {
+        (this.outs as (Output | BlankOutput)[]).forEach((txOut) => {
             if (isOutput(txOut)) {
                 bufferWriter.writeUInt64(txOut.value);
             } else {
-                bufferWriter.writeSlice((txOut as any).valueBuffer);
+                bufferWriter.writeSlice(txOut.valueBuffer);
             }
 
             bufferWriter.writeVarSlice(txOut.script);
@@ -650,7 +663,7 @@ export class Transaction {
         bufferWriter.writeUInt32(this.locktime);
 
         // avoid slicing unless necessary
-        if (initialOffset !== undefined) return buffer.slice(initialOffset, bufferWriter.offset);
+        if (initialOffset !== undefined) return buffer.subarray(initialOffset, bufferWriter.offset);
         return buffer;
     }
 }

package/src/typeforce.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Type definitions for typeforce library
+ */
+
+/**
+ * Typeforce type validator - validates that a value matches a given type.
+ */
+type TypeforceValidator = (value: unknown) => boolean;
+
+/**
+ * Interface representing the typeforce library's API.
+ */
+interface TypeforceLib {
+    (type: unknown, value: unknown): void;
+    Number: TypeforceValidator;
+    Array: TypeforceValidator;
+    Boolean: TypeforceValidator;
+    String: TypeforceValidator;
+    Buffer: TypeforceValidator;
+    Hex: TypeforceValidator;
+    Null: TypeforceValidator;
+    Function: TypeforceValidator;
+    UInt8: TypeforceValidator;
+    UInt32: TypeforceValidator;
+    UInt53: TypeforceValidator;
+    BufferN: (n: number) => TypeforceValidator;
+    maybe: (type: unknown) => TypeforceValidator;
+    tuple: (...types: unknown[]) => TypeforceValidator;
+    oneOf: (...types: unknown[]) => TypeforceValidator;
+    arrayOf: (type: unknown) => TypeforceValidator;
+    Object: TypeforceValidator;
+    anyOf: (...types: unknown[]) => TypeforceValidator;
+}
+
+declare module 'typeforce' {
+    const typeforce: TypeforceLib;
+    export = typeforce;
+}

package/src/types.ts

@@ -1,9 +1,12 @@
 import { Buffer as NBuffer } from 'buffer';
+import typeforce from 'typeforce';
 
-// @ts-ignore
-import * as _typeforce from 'typeforce';
+export { typeforce };
 
-export const typeforce = _typeforce.default;
+/**
+ * Typeforce type validator - validates that a value matches a given type.
+ */
+export type TypeforceValidator = (value: unknown) => boolean;
 
 const ZERO32 = NBuffer.alloc(32, 0);
 const EC_P = NBuffer.from(
@@ -35,7 +38,7 @@ export function isPoint(p: Buffer | number | undefined | null): boolean {
     if (p.length < 33) return false;
 
     const t = p[0]; // First byte = point format indicator
-    const x = p.slice(1, 33); // Next 32 bytes = X coordinate
+    const x = p.subarray(1, 33); // Next 32 bytes = X coordinate
 
     // Validate X coordinate
     if (x.compare(ZERO32) === 0) return false; // X cannot be zero
@@ -49,7 +52,7 @@ export function isPoint(p: Buffer | number | undefined | null): boolean {
     // For uncompressed (0x04) or hybrid (0x06 or 0x07) formats, must be 65 bytes total
     if (p.length !== 65) return false;
 
-    const y = p.slice(33); // Last 32 bytes = Y coordinate
+    const y = p.subarray(33); // Last 32 bytes = Y coordinate
 
     // Validate Y coordinate
     if (y.compare(ZERO32) === 0) return false; // Y cannot be zero
@@ -77,10 +80,12 @@ export interface Tapleaf {
 
 export const TAPLEAF_VERSION_MASK = 0xfe;
 
-export function isTapleaf(o: any): o is Tapleaf {
-    if (!o || !('output' in o)) return false;
-    if (!NBuffer.isBuffer(o.output)) return false;
-    if (o.version !== undefined) return (o.version & TAPLEAF_VERSION_MASK) === o.version;
+export function isTapleaf(o: unknown): o is Tapleaf {
+    if (!o || typeof o !== 'object' || !('output' in o)) return false;
+    const obj = o as Record<string, unknown>;
+    if (!NBuffer.isBuffer(obj.output)) return false;
+    if (obj.version !== undefined)
+        return ((obj.version as number) & TAPLEAF_VERSION_MASK) === obj.version;
     return true;
 }
 
@@ -91,10 +96,10 @@ export function isTapleaf(o: any): o is Tapleaf {
  */
 export type Taptree = [Taptree | Tapleaf, Taptree | Tapleaf] | Tapleaf;
 
-export function isTaptree(scriptTree: any): scriptTree is Taptree {
-    if (!Array(scriptTree)) return isTapleaf(scriptTree);
+export function isTaptree(scriptTree: unknown): scriptTree is Taptree {
+    if (!globalThis.Array.isArray(scriptTree)) return isTapleaf(scriptTree);
     if (scriptTree.length !== 2) return false;
-    return scriptTree.every((t: any) => isTaptree(t));
+    return scriptTree.every((t: unknown) => isTaptree(t));
 }
 
 export interface TinySecp256k1Interface {
@@ -103,20 +108,20 @@ export interface TinySecp256k1Interface {
     xOnlyPointAddTweak(p: Uint8Array, tweak: Uint8Array): XOnlyPointAddTweakResult | null;
 }
 
-export const Buffer256bit = typeforce.BufferN(32);
-export const Hash160bit = typeforce.BufferN(20);
-export const Hash256bit = typeforce.BufferN(32);
-export const Number = typeforce.Number;
-export const Array = typeforce.Array;
-export const Boolean = typeforce.Boolean;
-export const String = typeforce.String;
-export const Buffer = typeforce.Buffer;
-export const Hex = typeforce.Hex;
-export const maybe = typeforce.maybe;
-export const tuple = typeforce.tuple;
-export const UInt8 = typeforce.UInt8;
-export const UInt32 = typeforce.UInt32;
-export const Function = typeforce.Function;
-export const BufferN = typeforce.BufferN;
-export const Null = typeforce.Null;
-export const oneOf = typeforce.oneOf;
+export const Buffer256bit: TypeforceValidator = typeforce.BufferN(32);
+export const Hash160bit: TypeforceValidator = typeforce.BufferN(20);
+export const Hash256bit: TypeforceValidator = typeforce.BufferN(32);
+export const Number: TypeforceValidator = typeforce.Number;
+export const Array: TypeforceValidator = typeforce.Array;
+export const Boolean: TypeforceValidator = typeforce.Boolean;
+export const String: TypeforceValidator = typeforce.String;
+export const Buffer: TypeforceValidator = typeforce.Buffer;
+export const Hex: TypeforceValidator = typeforce.Hex;
+export const maybe: (type: unknown) => TypeforceValidator = typeforce.maybe;
+export const tuple: (...types: unknown[]) => TypeforceValidator = typeforce.tuple;
+export const UInt8: TypeforceValidator = typeforce.UInt8;
+export const UInt32: TypeforceValidator = typeforce.UInt32;
+export const Function: TypeforceValidator = typeforce.Function;
+export const BufferN: (n: number) => TypeforceValidator = typeforce.BufferN;
+export const Null: TypeforceValidator = typeforce.Null;
+export const oneOf: (...types: unknown[]) => TypeforceValidator = typeforce.oneOf;

package/test/address.spec.ts

@@ -1,13 +1,13 @@
 import assert from 'assert';
-import { describe, it } from 'mocha';
+import { describe, it } from 'vitest';
 import * as ecc from 'tiny-secp256k1';
 import * as baddress from '../src/address.js';
 import * as bscript from '../src/script.js';
 import fixtures from './fixtures/address.json' with { type: 'json' };
 
-import { initEccLib, Network } from '../src/index.js';
-
+import { initEccLib } from '../src/index.js';
 import * as networks from '../src/networks.js';
+import type { Network } from '../src/networks.js';
 
 const NETWORKS: Record<string, Network> = Object.assign(
     {
@@ -20,6 +20,8 @@ const NETWORKS: Record<string, Network> = Object.assign(
             pubKeyHash: 0x30,
             scriptHash: 0x32,
             wif: 0xb0,
+            bech32: 'ltc',
+            bech32Opnet: 'opl',
         },
     },
     networks,
@@ -58,7 +60,13 @@ describe('address', () => {
                 const actual = baddress.fromBech32(f.bech32);
 
                 assert.strictEqual(actual.version, f.version);
-                assert.strictEqual(actual.prefix, NETWORKS[f.network].bech32);
+                // Support both bech32 and bech32Opnet prefixes
+                const network = NETWORKS[f.network];
+                const validPrefixes = [network.bech32, network.bech32Opnet].filter(Boolean);
+                assert.ok(
+                    validPrefixes.includes(actual.prefix),
+                    `Expected prefix to be one of [${validPrefixes.join(', ')}], got ${actual.prefix}`,
+                );
                 assert.strictEqual(actual.data.toString('hex'), f.data);
             });
         });

package/test/bitcoin.core.spec.ts

@@ -1,6 +1,6 @@
 import assert from 'assert';
 import base58 from 'bs58';
-import { describe, it } from 'mocha';
+import { describe, it } from 'vitest';
 import * as bitcoin from '../src/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' };

package/test/block.spec.ts

@@ -1,5 +1,5 @@
 import assert from 'assert';
-import { beforeEach, describe, it } from 'mocha';
+import { beforeEach, describe, it } from 'vitest';
 import { Block } from '../src/index.js';
 
 import fixtures from './fixtures/block.json' with { type: 'json' };

package/test/bufferutils.spec.ts

@@ -1,5 +1,5 @@
 import assert from 'assert';
-import { describe, it } from 'mocha';
+import { describe, it } from 'vitest';
 import * as bufferutils from '../src/bufferutils.js';
 import { BufferReader, BufferWriter } from '../src/bufferutils.js';
 

package/test/crypto.spec.ts

@@ -1,6 +1,7 @@
 import assert from 'assert';
-import { describe, it } from 'mocha';
-import { crypto as bcrypto, TaggedHashPrefix } from '../src/index.js';
+import { describe, it } from 'vitest';
+import { crypto as bcrypto } from '../src/index.js';
+import type { TaggedHashPrefix } from '../src/crypto.js';
 import fixtures from './fixtures/crypto.json' with { type: 'json' };
 import { sha256, TAGGED_HASH_PREFIXES, TAGS } from '../src/crypto.js';
 

package/test/fixtures/address.json

@@ -86,7 +86,7 @@
         },
         {
             "network": "bitcoin",
-            "bech32": "opnet1sw50qpgryz8",
+            "bech32": "op1sw50qcspuvz",
             "version": 16,
             "data": "751e",
             "script": "OP_16 751e"

package/test/integration/addresses.spec.ts

@@ -1,7 +1,7 @@
 import assert from 'assert';
 import { ECPairFactory } from 'ecpair';
 import * as ecc from 'tiny-secp256k1';
-import { describe, it } from 'mocha';
+import { describe, it } from 'vitest';
 import * as bitcoin from '../../src/index.js';
 import { regtestUtils } from './_regtest.js';
 

package/test/integration/bip32.spec.ts

@@ -1,8 +1,8 @@
 import assert from 'assert';
-import { BIP32Factory } from 'bip32';
+import { BIP32Factory } from '@btc-vision/bip32';
 import * as ecc from 'tiny-secp256k1';
 import * as bip39 from 'bip39';
-import { describe, it } from 'mocha';
+import { describe, it } from 'vitest';
 import * as bitcoin from '../../src/index.js';
 
 const bip32 = BIP32Factory(ecc);

package/test/integration/blocks.spec.ts

@@ -1,5 +1,5 @@
 import assert from 'assert';
-import { describe, it } from 'mocha';
+import { describe, it } from 'vitest';
 import * as bitcoin from '../../src/index.js';
 
 describe('bitcoinjs-lib (blocks)', () => {

package/test/integration/cltv.spec.ts

@@ -1,7 +1,7 @@
 import assert from 'assert';
 import { ECPairFactory } from 'ecpair';
 import * as ecc from 'tiny-secp256k1';
-import { before, describe, it } from 'mocha';
+import { beforeAll, describe, it } from 'vitest';
 import * as bitcoin from '../../src/index.js';
 import { regtestUtils } from './_regtest.js';
 
@@ -24,7 +24,7 @@ const bob = ECPair.fromWIF('cMkopUXKWsEzAjfa1zApksGRwjVpJRB3831qM9W4gKZsLwjHXA9x
 
 describe('bitcoinjs-lib (transactions w/ CLTV)', () => {
     // force update MTP
-    before(async () => {
+    beforeAll(async () => {
         await regtestUtils.mine(11);
     });
 
@@ -231,7 +231,7 @@ describe('bitcoinjs-lib (transactions w/ CLTV)', () => {
             }).input;
             tx.setInputScript(0, redeemScriptSig!);
 
-            await regtestUtils.broadcast(tx.toHex()).catch((err) => {
+            await regtestUtils.broadcast(tx.toHex()).catch((err: unknown) => {
                 assert.throws(() => {
                     if (err) throw err;
                 }, /Error: non-final/);

package/test/integration/csv.spec.ts

@@ -1,9 +1,9 @@
 import assert from 'assert';
-import { PsbtInput } from 'bip174/src/lib/interfaces.js';
 import { ECPairFactory } from 'ecpair';
 import * as ecc from 'tiny-secp256k1';
-import { before, describe, it } from 'mocha';
+import { beforeAll, describe, it } from 'vitest';
 import * as bitcoin from '../../src/index.js';
+import type { PsbtInput } from '../../src/index.js';
 import { regtestUtils } from './_regtest.js';
 
 // @ts-ignore
@@ -28,7 +28,7 @@ const dave = ECPair.fromWIF('cMkopUXKWsEzAjfa1zApksGRwjVpJRB3831qM9W4gKZsMwS4pqn
 
 describe('bitcoinjs-lib (transactions w/ CSV)', () => {
     // force update MTP
-    before(async () => {
+    beforeAll(async () => {
         await regtestUtils.mine(11);
     });
 

package/test/integration/payments.spec.ts

@@ -1,6 +1,6 @@
 import { ECPairFactory } from 'ecpair';
 import * as ecc from 'tiny-secp256k1';
-import { describe, it } from 'mocha';
+import { describe, it } from 'vitest';
 import * as bitcoin from '../../src/index.js';
 import { regtestUtils } from './_regtest.js';
 import * as fs from 'node:fs';

package/test/integration/taproot.spec.ts

@@ -1,12 +1,11 @@
 import assert from 'assert';
-import { BIP32Factory } from 'bip32';
+import { BIP32Factory } from '@btc-vision/bip32';
 import * as bip39 from 'bip39';
 import * as ecc from 'tiny-secp256k1';
-import { describe, it } from 'mocha';
-import { PsbtInput, TapLeaf, TapLeafScript } from 'bip174/src/lib/interfaces.js';
+import { describe, it } from 'vitest';
 import { regtestUtils } from './_regtest.js';
 import * as bitcoin from '../../src/index.js';
-import { Taptree } from '../../src/types.js';
+import type { PsbtInput, TapLeaf, TapLeafScript, Taptree } from '../../src/index.js';
 import { LEAF_VERSION_TAPSCRIPT } from '../../src/payments/bip341.js';
 import { tapTreeFromList, tapTreeToList, toXOnly } from '../../src/psbt/bip371.js';
 import { witnessStackToScriptWitness } from '../../src/psbt/psbtutils.js';
@@ -652,9 +651,11 @@ function buildLeafIndexFinalizer(
     } => {
         try {
             const scriptSolution = [Buffer.from([leafIndex]), Buffer.from([leafIndex])];
-            const witness = scriptSolution
-                .concat(tapLeafScript.script)
-                .concat(tapLeafScript.controlBlock);
+            const witness: Buffer[] = [
+                ...scriptSolution,
+                tapLeafScript.script,
+                tapLeafScript.controlBlock,
+            ];
             return { finalScriptWitness: witnessStackToScriptWitness(witness) };
         } catch (err) {
             throw new Error(`Can not finalize taproot input #${inputIndex}: ${err}`);

package/test/integration/transactions.spec.ts

@@ -1,8 +1,8 @@
 import assert from 'assert';
-import { BIP32Factory } from 'bip32';
+import { BIP32Factory } from '@btc-vision/bip32';
 import * as ecc from 'tiny-secp256k1';
 import { ECPairFactory } from 'ecpair';
-import { describe, it } from 'mocha';
+import { describe, it } from 'vitest';
 import * as bitcoin from '../../src/index.js';
 import { regtestUtils } from './_regtest.js';
 

package/test/payments.spec.ts

@@ -1,10 +1,11 @@
 import assert from 'assert';
 import * as ecc from 'tiny-secp256k1';
-import { describe, it } from 'mocha';
-import { initEccLib, PaymentCreator } from '../src/index.js';
+import { beforeEach, describe, it } from 'vitest';
+import { initEccLib } from '../src/index.js';
+import type { PaymentCreator, P2SHPayment } from '../src/payments/index.js';
 import * as u from './payments.utils.js';
 import fs from 'node:fs';
-import { p2pk, P2SHPayment, p2wsh } from '../src/payments/index.js';
+import { p2pk, p2wsh } from '../src/payments/index.js';
 
 const require = async (name: string) => {
     const mod = await import(name);