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

package/test/transaction.spec.ts

@@ -2,6 +2,7 @@ import assert from 'assert';
 import { beforeEach, describe, it } from 'vitest';
 import { Transaction } from '../src/index.js';
 import * as bscript from '../src/script.js';
+import type { Bytes32, Script, Satoshi } from '../src/types.js';
 import fixtures from './fixtures/transaction.json' with { type: 'json' };
 
 describe('Transaction', () => {
@@ -11,11 +12,11 @@ describe('Transaction', () => {
         tx.locktime = raw.locktime;
 
         raw.ins.forEach((txIn: any, i: number) => {
-            const txHash = Buffer.from(txIn.hash, 'hex');
+            const txHash = Buffer.from(txIn.hash, 'hex') as unknown as Bytes32;
             let scriptSig;
 
             if (txIn.data) {
-                scriptSig = Buffer.from(txIn.data, 'hex');
+                scriptSig = Buffer.from(txIn.data, 'hex') as unknown as Script;
             } else if (txIn.script) {
                 scriptSig = bscript.fromASM(txIn.script);
             }
@@ -32,15 +33,15 @@ describe('Transaction', () => {
         });
 
         raw.outs.forEach((txOut: any) => {
-            let script: Buffer;
+            let script: Script;
 
             if (txOut.data) {
-                script = Buffer.from(txOut.data, 'hex');
+                script = Buffer.from(txOut.data, 'hex') as unknown as Script;
             } else if (txOut.script) {
                 script = bscript.fromASM(txOut.script);
             }
 
-            tx.addOutput(script!, txOut.value);
+            tx.addOutput(script!, BigInt(txOut.value) as Satoshi);
         });
 
         return tx;
@@ -112,11 +113,11 @@ describe('Transaction', () => {
 
             assert.strictEqual(a.length, byteLength);
             assert.strictEqual(b.length, byteLength);
-            assert.strictEqual(a.toString('hex'), f.hex);
-            assert.strictEqual(b.toString('hex'), f.hex);
+            assert.strictEqual(Buffer.from(a).toString('hex'), f.hex);
+            assert.strictEqual(Buffer.from(b).toString('hex'), f.hex);
             assert.deepStrictEqual(a, b);
-            assert.deepStrictEqual(a, target.slice(0, byteLength));
-            assert.deepStrictEqual(b, target.slice(byteLength));
+            assert.deepStrictEqual(Buffer.from(a), target.slice(0, byteLength));
+            assert.deepStrictEqual(Buffer.from(b), target.slice(byteLength));
         });
     });
 
@@ -150,12 +151,12 @@ describe('Transaction', () => {
     });
 
     describe('addInput', () => {
-        let prevTxHash: Buffer;
+        let prevTxHash: Bytes32;
         beforeEach(() => {
             prevTxHash = Buffer.from(
                 'ffffffff00ffff000000000000000000000000000000000000000000101010ff',
                 'hex',
-            );
+            ) as unknown as Bytes32;
         });
 
         it('returns an index', () => {
@@ -176,7 +177,7 @@ describe('Transaction', () => {
         fixtures.invalid.addInput.forEach((f) => {
             it('throws on ' + f.exception, () => {
                 const tx = new Transaction();
-                const hash = Buffer.from(f.hash, 'hex');
+                const hash = Buffer.from(f.hash, 'hex') as unknown as Bytes32;
 
                 assert.throws(() => {
                     tx.addInput(hash, f.index);
@@ -188,8 +189,8 @@ describe('Transaction', () => {
     describe('addOutput', () => {
         it('returns an index', () => {
             const tx = new Transaction();
-            assert.strictEqual(tx.addOutput(Buffer.alloc(0), 0), 0);
-            assert.strictEqual(tx.addOutput(Buffer.alloc(0), 0), 1);
+            assert.strictEqual(tx.addOutput(Buffer.alloc(0) as unknown as Script, 0n as Satoshi), 0);
+            assert.strictEqual(tx.addOutput(Buffer.alloc(0) as unknown as Script, 0n as Satoshi), 1);
         });
     });
 
@@ -218,7 +219,7 @@ describe('Transaction', () => {
             it('should return the id for ' + f.id + '(' + f.description + ')', () => {
                 const tx = Transaction.fromHex(f.whex || f.hex);
 
-                assert.strictEqual(tx.getHash().toString('hex'), f.hash);
+                assert.strictEqual(Buffer.from(tx.getHash()).toString('hex'), f.hash);
                 assert.strictEqual(tx.getId(), f.id);
             });
         }
@@ -247,25 +248,18 @@ describe('Transaction', () => {
                 Buffer.from(
                     '0000000000000000000000000000000000000000000000000000000000000000',
                     'hex',
-                ),
+                ) as unknown as Bytes32,
                 0,
             );
-            tx.addOutput(randScript, 5000000000);
-
-            const original = (tx as any).__toBuffer;
-            (tx as any).__toBuffer = function (this: Transaction, a: any, b: any, c: any): any {
-                if (c !== false) throw new Error('hashForSignature MUST pass false');
+            tx.addOutput(randScript as unknown as Script, 5000000000n as Satoshi);
 
-                return original.call(this, a, b, c);
-            };
-
-            assert.throws(() => {
-                (tx as any).__toBuffer(undefined, undefined, true);
-            }, /hashForSignature MUST pass false/);
+            // Note: __toBuffer has been converted to #toBuffer (true private field)
+            // which cannot be accessed from tests. The behavior is tested through
+            // the expected hash output in the fixtures below.
 
-            // assert hashForSignature does not pass false
+            // Test that hashForSignature works correctly
             assert.doesNotThrow(() => {
-                tx.hashForSignature(0, randScript, 1);
+                tx.hashForSignature(0, randScript as unknown as Script, 1);
             });
         });
 
@@ -280,7 +274,7 @@ describe('Transaction', () => {
                     const script = bscript.fromASM(f.script);
 
                     assert.strictEqual(
-                        tx.hashForSignature(f.inIndex, script, f.type).toString('hex'),
+                        Buffer.from(tx.hashForSignature(f.inIndex, script, f.type)).toString('hex'),
                         f.hash,
                     );
                 },
@@ -299,10 +293,8 @@ describe('Transaction', () => {
                     const tx = Transaction.fromHex(f.txHex);
                     const script = bscript.fromASM(f.script);
 
-                    assert.strictEqual(
-                        tx.hashForWitnessV0(f.inIndex, script, f.value, f.type).toString('hex'),
-                        f.hash,
-                    );
+                    const hash = tx.hashForWitnessV0(f.inIndex, script, BigInt(f.value) as Satoshi, f.type);
+                    assert.strictEqual(Buffer.from(hash).toString('hex'), f.hash);
                 },
             );
         });
@@ -311,27 +303,27 @@ describe('Transaction', () => {
     describe('taprootSigning', () => {
         fixtures.taprootSigning.forEach((f) => {
             const tx = Transaction.fromHex(f.txHex);
-            const prevOutScripts = f.utxos.map(({ scriptHex }) => Buffer.from(scriptHex, 'hex'));
-            const values = f.utxos.map(({ value }) => value);
+            const prevOutScripts = f.utxos.map(({ scriptHex }) => Buffer.from(scriptHex, 'hex')) as unknown as Script[];
+            const values = f.utxos.map(({ value }) => BigInt(value)) as Satoshi[];
 
             f.cases.forEach((c) => {
-                let hash: Buffer;
+                let hash: Uint8Array;
 
                 it(`should hash to ${c.hash} for ${f.description}:${c.vin}`, () => {
                     const hashType = Buffer.from(c.typeHex, 'hex').readUInt8(0);
 
                     hash = tx.hashForWitnessV1(c.vin, prevOutScripts, values, hashType);
-                    assert.strictEqual(hash.toString('hex'), c.hash);
+                    assert.strictEqual(Buffer.from(hash).toString('hex'), c.hash);
                 });
             });
         });
     });
 
     describe('setWitness', () => {
-        it('only accepts a witness stack (Array of Buffers)', () => {
+        it('only accepts a witness stack (Array of Uint8Arrays)', () => {
             assert.throws(() => {
                 (new Transaction().setWitness as any)(0, 'foobar');
-            }, /Expected property "1" of type \[Buffer], got String "foobar"/);
+            }, /Expected array of Uint8Array for witness/);
         });
     });
 });

package/test/types.spec.ts

@@ -2,52 +2,97 @@ import assert from 'assert';
 import { describe, it } from 'vitest';
 import * as types from '../src/types.js';
 
-// @ts-ignore
-import typeforce from 'typeforce';
-
 describe('types', () => {
-    describe('Buffer Hash160/Hash256', () => {
-        const buffer20byte = Buffer.alloc(20);
-        const buffer32byte = Buffer.alloc(32);
+    describe('Buffer validation', () => {
+        const buffer20byte = new Uint8Array(20);
+        const buffer32byte = new Uint8Array(32);
 
-        it('return true for valid size', () => {
-            assert(types.Hash160bit(buffer20byte));
-            assert(types.Hash256bit(buffer32byte));
+        it('isBytes20 returns true for 20-byte buffer', () => {
+            assert(types.isBytes20(buffer20byte));
         });
 
-        it('return true for oneOf', () => {
-            assert.doesNotThrow(() => {
-                typeforce(types.oneOf(types.Hash160bit, types.Hash256bit), buffer32byte);
-            });
+        it('isBytes32 returns true for 32-byte buffer', () => {
+            assert(types.isBytes32(buffer32byte));
+        });
 
-            assert.doesNotThrow(() => {
-                typeforce(types.oneOf(types.Hash256bit, types.Hash160bit), buffer32byte);
-            });
+        it('isBytes20 returns false for wrong size', () => {
+            assert.strictEqual(types.isBytes20(buffer32byte), false);
+        });
+
+        it('isBytes32 returns false for wrong size', () => {
+            assert.strictEqual(types.isBytes32(buffer20byte), false);
         });
 
-        it('throws for invalid size', () => {
+        it('toBytes20 throws for invalid size', () => {
             assert.throws(() => {
-                types.Hash160bit(buffer32byte);
-            }, /Expected Buffer\(Length: 20\), got Buffer\(Length: 32\)/);
+                types.toBytes20(buffer32byte);
+            }, /Expected 20-byte Uint8Array/);
+        });
 
+        it('toBytes32 throws for invalid size', () => {
             assert.throws(() => {
-                types.Hash256bit(buffer20byte);
-            }, /Expected Buffer\(Length: 32\), got Buffer\(Length: 20\)/);
+                types.toBytes32(buffer20byte);
+            }, /Expected 32-byte Uint8Array/);
         });
     });
 
     describe('Satoshi', () => {
         [
-            { value: -1, result: false },
-            { value: 0, result: true },
-            { value: 1, result: true },
-            { value: 20999999 * 1e8, result: true },
-            { value: 21000000 * 1e8, result: true },
-            { value: 21000001 * 1e8, result: false },
+            { value: -1n, result: false },
+            { value: 0n, result: true },
+            { value: 1n, result: true },
+            { value: 20999999n * 100000000n, result: true },
+            { value: 21000000n * 100000000n, result: true },
+            { value: 21000001n * 100000000n, result: false },
         ].forEach((f) => {
-            it('returns ' + f.result + ' for valid for ' + f.value, () => {
-                assert.strictEqual(types.Satoshi(f.value), f.result);
+            it('returns ' + f.result + ' for value ' + f.value, () => {
+                assert.strictEqual(types.isSatoshi(f.value), f.result);
             });
         });
     });
+
+    describe('Type guards', () => {
+        it('isUInt8 validates correctly', () => {
+            assert.strictEqual(types.isUInt8(0), true);
+            assert.strictEqual(types.isUInt8(255), true);
+            assert.strictEqual(types.isUInt8(256), false);
+            assert.strictEqual(types.isUInt8(-1), false);
+            assert.strictEqual(types.isUInt8(1.5), false);
+        });
+
+        it('isUInt32 validates correctly', () => {
+            assert.strictEqual(types.isUInt32(0), true);
+            assert.strictEqual(types.isUInt32(0xffffffff), true);
+            assert.strictEqual(types.isUInt32(0x100000000), false);
+            assert.strictEqual(types.isUInt32(-1), false);
+        });
+
+        it('isHex validates correctly', () => {
+            assert.strictEqual(types.isHex('abcd'), true);
+            assert.strictEqual(types.isHex('ABCD'), true);
+            assert.strictEqual(types.isHex('1234'), true);
+            assert.strictEqual(types.isHex('abc'), false); // odd length
+            assert.strictEqual(types.isHex('ghij'), false); // invalid chars
+        });
+
+        it('isUint8Array validates correctly', () => {
+            assert.strictEqual(types.isUint8Array(new Uint8Array(10)), true);
+            assert.strictEqual(types.isUint8Array(Buffer.alloc(10)), true);
+            assert.strictEqual(types.isUint8Array([1, 2, 3]), false);
+            assert.strictEqual(types.isUint8Array('hello'), false);
+        });
+
+        it('isPoint validates public keys', () => {
+            // Compressed pubkey (33 bytes, prefix 0x02 or 0x03)
+            const compressedKey = new Uint8Array(33);
+            compressedKey[0] = 0x02;
+            compressedKey[1] = 0x01; // non-zero x coordinate
+
+            // Invalid: all zeros
+            const zeroKey = new Uint8Array(33);
+            zeroKey[0] = 0x02;
+
+            assert.strictEqual(types.isPoint(zeroKey), false);
+        });
+    });
 });