@btc-vision/bitcoin 7.0.0-alpha.9 → 7.0.0-beta.0

package/test/integration/payments.spec.ts

@@ -42,7 +42,7 @@ async function buildAndSign(
             psbt.signInput(0, keyPair);
         });
     } else if (depends.signature) {
-        psbt.signInput(0, keyPairs[0]);
+        psbt.signInput(0, keyPairs[0]!);
     }
 
     return regtestUtils.broadcast(psbt.finalizeAllInputs().extractTransaction().toHex());
@@ -54,7 +54,7 @@ async function buildAndSign(
     const fn: any = (bitcoin.payments as any)[k];
 
     const base: any = {};
-    if (depends.pubkey) base.pubkey = keyPairs[0].publicKey;
+    if (depends.pubkey) base.pubkey = keyPairs[0]!.publicKey;
     if (depends.pubkeys) base.pubkeys = keyPairs.map((x) => x.publicKey);
     if (depends.m) base.m = base.pubkeys.length;
 

package/test/integration/taproot.spec.ts

@@ -508,9 +508,9 @@ describe('bitcoinjs-lib (transaction with taproot)', () => {
         psbt.addOutput({ value: BigInt(sendAmount) as Satoshi, address: address! });
 
         // random order for signers
-        psbt.signInput(0, leafKeys[1]);
-        psbt.signInput(0, leafKeys[2]);
-        psbt.signInput(0, leafKeys[0]);
+        psbt.signInput(0, leafKeys[1]!);
+        psbt.signInput(0, leafKeys[2]!);
+        psbt.signInput(0, leafKeys[0]!);
 
         psbt.finalizeInput(0);
         const tx = psbt.extractTransaction();

package/test/integration/transactions.spec.ts

@@ -2,7 +2,8 @@ import assert from 'assert';
 import { BIP32Factory } from '@btc-vision/bip32';
 import * as ecc from 'tiny-secp256k1';
 import { describe, it } from 'vitest';
-import type { MessageHash, PrivateKey, PublicKey, Satoshi, Signature } from '../../src/index.js';
+import type { PrivateKey, PublicKey, Satoshi, Signature } from '../../src/index.js';
+import type { MessageHash } from '../../src/types.js';
 import * as bitcoin from '../../src/index.js';
 import { compare, fromHex } from '../../src/index.js';
 import type { HDSigner } from '../../src/psbt/types.js';
@@ -600,13 +601,13 @@ describe('bitcoinjs-lib (transactions with psbt)', () => {
 function createPayment(_type: string, myKeys?: any[], network?: any): any {
     network = network || regtest;
     const splitType = _type.split('-').reverse();
-    const isMultisig = splitType[0].slice(0, 4) === 'p2ms';
+    const isMultisig = splitType[0]!.slice(0, 4) === 'p2ms';
     const keys = myKeys || [];
     let m: number | undefined;
     if (isMultisig) {
-        const match = splitType[0].match(/^p2ms\((\d+) of (\d+)\)$/);
-        m = parseInt(match![1], 10);
-        let n = parseInt(match![2], 10);
+        const match = splitType[0]!.match(/^p2ms\((\d+) of (\d+)\)$/);
+        m = parseInt(match![1]!, 10);
+        let n = parseInt(match![2]!, 10);
         if (keys.length > 0 && keys.length !== n) {
             throw new Error('Need n keys for multisig');
         }

package/test/psbt.spec.ts

@@ -42,8 +42,8 @@ const initBuffers = (object: any): typeof preFixtures =>
         const result = regex.exec(value);
         if (!result) return value;
 
-        const data = result[1];
-        const encoding = result[2];
+        const data = result[1] as string;
+        const encoding = result[2] as string;
 
         return Buffer.from(data, encoding as BufferEncoding);
     });
@@ -55,7 +55,7 @@ const upperCaseFirstLetter = (str: string): string => str.replace(/^./, (s) => s
 const toAsyncSigner = (signer: Signer): SignerAsync => {
     return {
         publicKey: signer.publicKey,
-        sign: (hash: Bytes32, lowerR: boolean | undefined): Promise<Signature> => {
+        sign: (hash: MessageHash, lowerR: boolean | undefined): Promise<Signature> => {
             return new Promise((resolve, rejects): void => {
                 setTimeout(() => {
                     try {
@@ -69,10 +69,10 @@ const toAsyncSigner = (signer: Signer): SignerAsync => {
         },
     };
 };
-const failedAsyncSigner = (publicKey: Buffer): SignerAsync => {
+const failedAsyncSigner = (publicKey: Uint8Array): SignerAsync => {
     return <SignerAsync>{
         publicKey: publicKey as unknown as PublicKey,
-        sign: (__: Bytes32): Promise<Signature> => {
+        sign: (__: MessageHash): Promise<Signature> => {
             return new Promise((_, reject): void => {
                 setTimeout(() => {
                     reject(new Error('sign failed'));
@@ -178,14 +178,17 @@ describe(`Psbt`, () => {
         fixtures.bip174.combiner.forEach((f) => {
             it('Combines two PSBTs to the expected result', () => {
                 const psbts = f.psbts.map((psbt) => Psbt.fromBase64(psbt));
+                const psbt0 = psbts[0];
+                const psbt1 = psbts[1];
+                assert(psbt0 && psbt1);
 
-                psbts[0].combine(psbts[1]);
+                psbt0.combine(psbt1);
 
                 // Produces a different Base64 string due to implementation specific key-value ordering.
                 // That means this test will fail:
                 // assert.strictEqual(psbts[0].toBase64(), f.result)
                 // Compare the serialized PSBT hex instead - this is deterministic
-                assert.strictEqual(psbts[0].toHex(), Psbt.fromBase64(f.result).toHex());
+                assert.strictEqual(psbt0.toHex(), Psbt.fromBase64(f.result).toHex());
             });
         });
 
@@ -212,8 +215,10 @@ describe(`Psbt`, () => {
                 assert.strictEqual(transaction1, f.transaction);
 
                 const psbt3 = Psbt.fromBase64(f.psbt);
-                delete psbt3.data.inputs[0].finalScriptSig;
-                delete psbt3.data.inputs[0].finalScriptWitness;
+                const psbt3Input0 = psbt3.data.inputs[0];
+                assert(psbt3Input0);
+                delete psbt3Input0.finalScriptSig;
+                delete psbt3Input0.finalScriptWitness;
                 assert.throws(() => {
                     psbt3.extractTransaction();
                 }, new RegExp('Not finalized'));
@@ -691,9 +696,13 @@ describe(`Psbt`, () => {
             });
 
             assert.strictEqual(psbt.inputCount, 1);
-            assert.strictEqual(psbt.txInputs[0].sequence, 0xffffffff);
+            const txIn0 = psbt.txInputs[0];
+            assert(txIn0);
+            assert.strictEqual(txIn0.sequence, 0xffffffff);
             psbt.setInputSequence(0, 0);
-            assert.strictEqual(psbt.txInputs[0].sequence, 0);
+            const txIn0After = psbt.txInputs[0];
+            assert(txIn0After);
+            assert.strictEqual(txIn0After.sequence, 0);
         });
 
         it('throws if input index is too high', () => {
@@ -847,6 +856,9 @@ describe(`Psbt`, () => {
                 index: 0,
             });
 
+            const input0 = psbt.data.inputs[0];
+            assert(input0);
+
             assert.throws(() => {
                 psbt.inputHasPubkey(0, testPubkey);
             }, new RegExp("Can't find pubkey in input without Utxo data"));
@@ -856,7 +868,7 @@ describe(`Psbt`, () => {
                     value: 1337n as Satoshi,
                     script: payments.p2sh({
                         redeem: { output: Buffer.from([0x51]) as unknown as Script },
-                    }).output!,
+                    }).output as Script,
                 },
             });
 
@@ -864,14 +876,14 @@ describe(`Psbt`, () => {
                 psbt.inputHasPubkey(0, testPubkey);
             }, new RegExp('scriptPubkey is P2SH but redeemScript missing'));
 
-            delete psbt.data.inputs[0].witnessUtxo;
+            delete input0.witnessUtxo;
 
             psbt.updateInput(0, {
                 witnessUtxo: {
                     value: 1337n as Satoshi,
                     script: payments.p2wsh({
                         redeem: { output: Buffer.from([0x51]) as unknown as Script },
-                    }).output!,
+                    }).output as Script,
                 },
             });
 
@@ -879,7 +891,7 @@ describe(`Psbt`, () => {
                 psbt.inputHasPubkey(0, testPubkey);
             }, new RegExp('scriptPubkey or redeemScript is P2WSH but witnessScript missing'));
 
-            delete psbt.data.inputs[0].witnessUtxo;
+            delete input0.witnessUtxo;
 
             // Create a script that contains the test pubkey
             const scriptWithPubkey = Buffer.concat([
@@ -1011,7 +1023,9 @@ describe(`Psbt`, () => {
                 psbt3.outputHasPubkey(0, testPubkey);
             }, new RegExp('scriptPubkey or redeemScript is P2WSH but witnessScript missing'));
 
-            delete psbt3.data.outputs[0].redeemScript;
+            const psbt3Output0 = psbt3.data.outputs[0];
+            assert(psbt3Output0);
+            delete psbt3Output0.redeemScript;
 
             psbt.updateOutput(0, {
                 witnessScript: scriptWithPubkey,
@@ -1046,7 +1060,9 @@ describe(`Psbt`, () => {
             assert.strictEqual(clone.toBase64(), notAClone.toBase64());
             assert.strictEqual(psbt.toBase64(), notAClone.toBase64());
             // Mutate data layer to prove clone is independent
-            psbt.data.inputs[0].partialSig = [];
+            const cloneInput0 = psbt.data.inputs[0];
+            assert(cloneInput0);
+            cloneInput0.partialSig = [];
             assert.notStrictEqual(clone.toBase64(), psbt.toBase64());
             assert.notStrictEqual(clone.toBase64(), notAClone.toBase64());
             assert.strictEqual(psbt.toBase64(), notAClone.toBase64());
@@ -1414,17 +1430,20 @@ describe(`Psbt`, () => {
             const psbt = Psbt.fromBase64(f.psbt);
             const index = f.inputIndex;
 
+            const cacheInput = psbt.data.inputs[index];
+            assert(cacheInput);
+
             // nonWitnessUtxo is not set before updateInput
-            assert.strictEqual(psbt.data.inputs[index].nonWitnessUtxo, undefined);
+            assert.strictEqual(cacheInput.nonWitnessUtxo, undefined);
 
             // After updateInput, the nonWitnessUtxo is stored on the input
             psbt.updateInput(index, {
                 nonWitnessUtxo: f.nonWitnessUtxo as any,
             });
-            assert.ok(psbt.data.inputs[index].nonWitnessUtxo);
+            assert.ok(cacheInput.nonWitnessUtxo);
             assert.ok(
                 equals(
-                    psbt.data.inputs[index].nonWitnessUtxo!,
+                    cacheInput.nonWitnessUtxo as Uint8Array,
                     f.nonWitnessUtxo as any,
                 ),
             );
@@ -1440,10 +1459,11 @@ describe(`Psbt`, () => {
             });
 
             const input = psbt.data.inputs[index];
+            assert(input);
             const desc = Object.getOwnPropertyDescriptor(input, 'nonWitnessUtxo');
             assert.ok(desc, 'property should exist');
-            assert.strictEqual(desc!.get, undefined, 'should not have a getter');
-            assert.strictEqual(desc!.set, undefined, 'should not have a setter');
+            assert.strictEqual(desc.get, undefined, 'should not have a getter');
+            assert.strictEqual(desc.set, undefined, 'should not have a setter');
         });
     });
 
@@ -1473,17 +1493,19 @@ describe(`Psbt`, () => {
             psbt.addInput({ hash, index });
 
             const input = psbt.txInputs[0];
+            assert(input);
             const originalHash = new Uint8Array(input.hash);
             const originalIndex = input.index;
             const originalSequence = input.sequence;
 
             // Mutate the returned clone
             input.hash[0] = 123;
-            input.index = 123;
-            input.sequence = 123;
+            (input as { index: number }).index = 123;
+            (input as { sequence: number }).sequence = 123;
 
             // Internal state should be unchanged
             const fresh = psbt.txInputs[0];
+            assert(fresh);
             assert.ok(equals(fresh.hash, originalHash));
             assert.strictEqual(fresh.index, originalIndex);
             assert.strictEqual(fresh.sequence, originalSequence);
@@ -1496,6 +1518,7 @@ describe(`Psbt`, () => {
             psbt.addOutput({ address, value });
 
             const output = psbt.txOutputs[0];
+            assert(output);
             assert.strictEqual(output.address, address);
 
             const originalScript = new Uint8Array(output.script);
@@ -1503,10 +1526,11 @@ describe(`Psbt`, () => {
 
             // Mutate the returned clone
             output.script[0] = 123;
-            output.value = 123n;
+            (output as { value: bigint }).value = 123n;
 
             // Internal state should be unchanged
             const fresh = psbt.txOutputs[0];
+            assert(fresh);
             assert.ok(equals(fresh.script, originalScript));
             assert.strictEqual(fresh.value, originalValue);
         });

package/test/transaction.spec.ts

@@ -104,6 +104,7 @@ describe('Transaction', () => {
 
         it('accepts target Buffer and offset parameters', () => {
             const f = fixtures.valid[0];
+            assert(f !== undefined);
             const actual = fromRaw(f.raw);
             const byteLength = actual.byteLength();
 
@@ -169,9 +170,11 @@ describe('Transaction', () => {
             const tx = new Transaction();
             tx.addInput(prevTxHash, 0);
 
-            assert.strictEqual(tx.ins[0].script.length, 0);
-            assert.strictEqual(tx.ins[0].witness.length, 0);
-            assert.strictEqual(tx.ins[0].sequence, 0xffffffff);
+            const firstIn = tx.ins[0];
+            assert(firstIn !== undefined);
+            assert.strictEqual(firstIn.script.length, 0);
+            assert.strictEqual(firstIn.witness.length, 0);
+            assert.strictEqual(firstIn.sequence, 0xffffffff);
         });
 
         fixtures.invalid.addInput.forEach((f) => {

package/test/workers-pool.spec.ts

@@ -125,7 +125,7 @@ class MockWorker {
 
 // Mock Worker that fails signing
 class MockFailingWorker extends MockWorker {
-    postMessage(data: unknown): void {
+    override postMessage(data: unknown): void {
         if ((data as { type: string }).type === 'signBatch') {
             setTimeout(() => {
                 const batchMsg = data as {
@@ -161,7 +161,7 @@ class MockFailingWorker extends MockWorker {
 
 // Mock Worker that times out (never responds)
 class MockTimeoutWorker extends MockWorker {
-    postMessage(data: unknown): void {
+    override postMessage(data: unknown): void {
         if ((data as { type: string }).type === 'signBatch') {
             // Never respond - simulates timeout
             // Still zero the key for security
@@ -188,7 +188,7 @@ beforeEach(() => {
         };
     }
 
-    (globalThis.URL as any).createObjectURL = vi.fn((blob: Blob) => {
+    (globalThis.URL as any).createObjectURL = vi.fn((_blob: Blob) => {
         const url = `blob:mock-${blobUrlCounter++}`;
         mockBlobUrls.push(url);
         return url;
@@ -634,7 +634,7 @@ describe('WorkerSigningPool', () => {
         it('should clean up with await using', async () => {
             WorkerSigningPool.resetInstance();
 
-            let poolRef: InstanceType<typeof WorkerSigningPool> | undefined;
+            let poolRef: import("../src/workers/WorkerSigningPool.js").WorkerSigningPool | undefined;
 
             // Scoped block — pool is disposed when the block exits
             {
@@ -732,7 +732,7 @@ describe('WorkerSigningPool Error Handling', () => {
         vi.resetModules();
 
         class MixedWorker extends MockWorker {
-            postMessage(data: unknown): void {
+            override postMessage(data: unknown): void {
                 if ((data as { type: string }).type === 'signBatch') {
                     setTimeout(() => {
                         const batchMsg = data as {

package/test/workers-signing.spec.ts

@@ -96,7 +96,7 @@ describe('Worker Signing - Signature Verification', () => {
 
             // Modify the hash
             const modifiedHash = Buffer.from(hash);
-            modifiedHash[0] ^= 0xff;
+            modifiedHash[0]! ^= 0xff;
 
             const isValid = ecc.verify(modifiedHash, keyPair.publicKey, signature);
             expect(isValid).toBe(false);
@@ -109,7 +109,7 @@ describe('Worker Signing - Signature Verification', () => {
             const signature = Buffer.from(ecc.sign(hash, keyPair.privateKey!));
 
             // Corrupt the signature
-            signature[0] ^= 0xff;
+            signature[0]! ^= 0xff;
 
             const isValid = ecc.verify(hash, keyPair.publicKey, signature);
             expect(isValid).toBe(false);
@@ -167,7 +167,7 @@ describe('Worker Signing - Signature Verification', () => {
             const signature = ecc.signSchnorr(hash, keyPair.privateKey!);
 
             const modifiedHash = Buffer.from(hash);
-            modifiedHash[0] ^= 0xff;
+            modifiedHash[0]! ^= 0xff;
 
             const xOnlyPubkey = toXOnly(keyPair.publicKey);
             const isValid = ecc.verifySchnorr(modifiedHash, xOnlyPubkey, signature);
@@ -179,7 +179,7 @@ describe('Worker Signing - Signature Verification', () => {
             const hash = randomBytes(32);
 
             const signature = Buffer.from(ecc.signSchnorr(hash, keyPair.privateKey!));
-            signature[0] ^= 0xff;
+            signature[0]! ^= 0xff;
 
             const xOnlyPubkey = toXOnly(keyPair.publicKey);
             const isValid = ecc.verifySchnorr(hash, xOnlyPubkey, signature);
@@ -190,7 +190,7 @@ describe('Worker Signing - Signature Verification', () => {
     describe('WorkerEccLib Interface Compatibility', () => {
         it('should create WorkerEccLib compatible wrapper', () => {
             const eccLib: WorkerEccLib = {
-                sign: (hash: Uint8Array, privateKey: Uint8Array, lowR?: boolean): Uint8Array => {
+                sign: (hash: Uint8Array, privateKey: Uint8Array, _lowR?: boolean): Uint8Array => {
                     return ecc.sign(hash, privateKey, undefined);
                 },
                 signSchnorr: (hash: Uint8Array, privateKey: Uint8Array): Uint8Array => {
@@ -284,7 +284,7 @@ describe('Worker Signing - Signature Verification', () => {
 
             // All signatures should be valid
             for (let i = 0; i < hashes.length; i++) {
-                expect(ecc.verify(hashes[i], keyPair.publicKey, signatures[i])).toBe(true);
+                expect(ecc.verify(hashes[i]!, keyPair.publicKey, signatures[i]!)).toBe(true);
             }
         });
 
@@ -354,7 +354,7 @@ describe('Worker Signing - Signature Verification', () => {
                 }
             });
 
-            const duration = Date.now() - startTime;
+            void (Date.now() - startTime);
 
             // Verify all signatures
             let validCount = 0;
@@ -442,7 +442,7 @@ describe('Worker Signing - Signature Verification', () => {
             let signature: Uint8Array;
 
             try {
-                if (signatureType === SignatureType.Schnorr) {
+                if ((signatureType as SignatureType) === SignatureType.Schnorr) {
                     if (!eccLib.signSchnorr) {
                         throw new Error('ECC library does not support Schnorr');
                     }

package/test/workers.spec.ts

@@ -306,7 +306,7 @@ describe('ParallelSignerKeyPair Interface', () => {
         const keyPair: ParallelSignerKeyPair = {
             publicKey,
             getPrivateKey: () => privateKey,
-            sign: (hash: Uint8Array, _lowR?: boolean) => new Uint8Array(64), // DER signature
+            sign: (_hash: Uint8Array, _lowR?: boolean) => new Uint8Array(64), // DER signature
         };
 
         expect(keyPair.sign).toBeDefined();
@@ -320,7 +320,7 @@ describe('ParallelSignerKeyPair Interface', () => {
         const keyPair: ParallelSignerKeyPair = {
             publicKey,
             getPrivateKey: () => privateKey,
-            signSchnorr: (hash: Uint8Array) => new Uint8Array(64), // Schnorr signature
+            signSchnorr: (_hash: Uint8Array) => new Uint8Array(64), // Schnorr signature
         };
 
         expect(keyPair.signSchnorr).toBeDefined();
@@ -1092,7 +1092,7 @@ describe('Batch Signing Scenarios', () => {
         ];
 
         expect(tasks.length).toBe(1);
-        expect(tasks[0].inputIndex).toBe(0);
+        expect(tasks[0]!.inputIndex).toBe(0);
     });
 
     it('should handle multi-input ECDSA signing', () => {