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

package/src/transaction.ts

@@ -144,7 +144,7 @@ export class Transaction {
 
         if (hasWitnesses) {
             for (let i = 0; i < vinLen; ++i) {
-                tx.ins[i]!.witness = bufferReader.readVector();
+                (tx.ins[i] as Transaction['ins'][0]).witness = bufferReader.readVector();
             }
 
             // was this pointless?
@@ -187,7 +187,8 @@ export class Transaction {
     }
 
     isCoinbase(): boolean {
-        return this.ins.length === 1 && Transaction.isCoinbaseHash(this.ins[0]!.hash);
+        const firstIn = this.ins[0];
+        return this.ins.length === 1 && firstIn !== undefined && Transaction.isCoinbaseHash(firstIn.hash);
     }
 
     /**
@@ -391,8 +392,8 @@ export class Transaction {
 
         // SIGHASH_ANYONECANPAY: ignore inputs entirely?
         if (hashType & Transaction.SIGHASH_ANYONECANPAY) {
-            txTmp.ins = [txTmp.ins[inIndex]!];
-            txTmp.ins[0]!.script = ourScript;
+            txTmp.ins = [txTmp.ins[inIndex] as Transaction['ins'][0]];
+            (txTmp.ins[0] as Transaction['ins'][0]).script = ourScript;
 
             // SIGHASH_ALL: only ignore input scripts
         } else {
@@ -400,7 +401,7 @@ export class Transaction {
             txTmp.ins.forEach((input) => {
                 input.script = EMPTY_BYTES;
             });
-            txTmp.ins[inIndex]!.script = ourScript;
+            (txTmp.ins[inIndex] as Transaction['ins'][0]).script = ourScript;
         }
 
         // serialize and hash
@@ -522,7 +523,7 @@ export class Transaction {
                 hashOutputs = bcrypto.sha256(bufferWriter.finish());
             }
         } else if (isSingle && inIndex < this.outs.length) {
-            const output = this.outs[inIndex]!;
+            const output = this.outs[inIndex] as Transaction['outs'][0];
 
             const bufferWriter = new BinaryWriter(8 + varSliceSize(output.script));
             bufferWriter.writeUInt64LE(output.value);
@@ -558,11 +559,11 @@ export class Transaction {
         // Input
         sigMsgWriter.writeUInt8(spendType);
         if (isAnyoneCanPay) {
-            const input = this.ins[inIndex]!;
+            const input = this.ins[inIndex] as Transaction['ins'][0];
             sigMsgWriter.writeBytes(input.hash);
             sigMsgWriter.writeUInt32LE(input.index);
-            sigMsgWriter.writeUInt64LE(values[inIndex]!);
-            sigMsgWriter.writeVarBytes(prevOutScripts[inIndex]!);
+            sigMsgWriter.writeUInt64LE(values[inIndex] as Satoshi);
+            sigMsgWriter.writeVarBytes(prevOutScripts[inIndex] as Uint8Array);
             sigMsgWriter.writeUInt32LE(input.sequence);
         } else {
             sigMsgWriter.writeUInt32LE(inIndex);
@@ -733,7 +734,7 @@ export class Transaction {
 
             hashOutputs = bcrypto.hash256(tbuffer);
         } else if ((hashType & 0x1f) === Transaction.SIGHASH_SINGLE && inIndex < this.outs.length) {
-            const output = this.outs[inIndex]!;
+            const output = this.outs[inIndex] as Transaction['outs'][0];
 
             tbuffer = alloc(8 + varSliceSize(output.script));
             bufferWriter = new BinaryWriter(tbuffer, 0);
@@ -746,7 +747,7 @@ export class Transaction {
         tbuffer = alloc(156 + varSliceSize(prevOutScript));
         bufferWriter = new BinaryWriter(tbuffer, 0);
 
-        const input = this.ins[inIndex]!;
+        const input = this.ins[inIndex] as Transaction['ins'][0];
         bufferWriter.writeInt32LE(this.version);
         bufferWriter.writeBytes(hashPrevouts);
         bufferWriter.writeBytes(hashSequence);
@@ -817,7 +818,7 @@ export class Transaction {
             throw new TypeError('Expected Uint8Array for scriptSig');
         }
 
-        this.ins[index]!.script = scriptSig;
+        (this.ins[index] as Transaction['ins'][0]).script = scriptSig;
     }
 
     /**
@@ -834,7 +835,7 @@ export class Transaction {
             throw new TypeError('Expected array of Uint8Array for witness');
         }
 
-        this.ins[index]!.witness = witness;
+        (this.ins[index] as Transaction['ins'][0]).witness = witness;
     }
 
     /**

package/src/types.ts

@@ -177,7 +177,7 @@ export type StackFunction = () => Stack;
 
 export function stacksEqual(a: Uint8Array[], b: Uint8Array[]): boolean {
     if (a.length !== b.length) return false;
-    return a.every((x, i) => equals(x, b[i]!));
+    return a.every((x, i) => equals(x, b[i] as Uint8Array));
 }
 
 export function toBytes32(value: Uint8Array): Bytes32 {

package/src/workers/WorkerSigningPool.node.ts

@@ -289,7 +289,7 @@ export class NodeWorkerSigningPool {
         const taskBatches: SigningTask[][] = Array.from({ length: workerCount }, () => []);
 
         for (let i = 0; i < tasks.length; i++) {
-            taskBatches[i % workerCount]!.push(tasks[i]!);
+            (taskBatches[i % workerCount] as SigningTask[]).push(tasks[i] as SigningTask);
         }
 
         // Get private key once
@@ -784,16 +784,40 @@ function handleSignBatch(msg) {
                 leafHash: task.leafHash,
             }));
 
+            // Copy private key for this worker (original shared across workers)
+            const workerPrivateKey = new Uint8Array(privateKey);
+
             // Create batch message
             const message: BatchSigningMessage = {
                 type: 'signBatch',
                 batchId,
                 tasks: batchTasks,
-                privateKey,
+                privateKey: workerPrivateKey,
             };
 
-            // Send to worker
-            worker.worker.postMessage(message);
+            // Collect ArrayBuffers for zero-copy transfer.
+            // Only transfer buffers unique to this worker batch — NOT publicKey
+            // (shared across all worker batches, would detach for other workers).
+            const keyBuf = workerPrivateKey.buffer;
+            const transferList: ArrayBuffer[] = [keyBuf];
+            const seen = new Set<ArrayBuffer>([keyBuf]);
+            for (const task of batchTasks) {
+                const hashBuf = task.hash.buffer as ArrayBuffer;
+                if (!seen.has(hashBuf)) {
+                    seen.add(hashBuf);
+                    transferList.push(hashBuf);
+                }
+                if (task.leafHash) {
+                    const leafBuf = task.leafHash.buffer as ArrayBuffer;
+                    if (!seen.has(leafBuf)) {
+                        seen.add(leafBuf);
+                        transferList.push(leafBuf);
+                    }
+                }
+            }
+
+            // Send to worker with transfer list (zero-copy)
+            worker.worker.postMessage(message, transferList);
         });
     }
 

package/src/workers/WorkerSigningPool.sequential.ts

@@ -142,7 +142,8 @@ export class SequentialSigningPool {
                     const key = privateKey as PrivateKey;
 
                     if (task.signatureType === SignatureType.Schnorr) {
-                        signature = ecc.signSchnorr!(hash, key);
+                        if (!ecc.signSchnorr) throw new Error('Schnorr signing not supported');
+                        signature = ecc.signSchnorr(hash, key);
                     } else {
                         signature = ecc.sign(hash, key);
                     }

package/src/workers/WorkerSigningPool.ts

@@ -319,7 +319,7 @@ export class WorkerSigningPool {
         const taskBatches: SigningTask[][] = Array.from({ length: workerCount }, () => []);
 
         for (let i = 0; i < tasks.length; i++) {
-            taskBatches[i % workerCount]!.push(tasks[i]!);
+            (taskBatches[i % workerCount] as SigningTask[]).push(tasks[i] as SigningTask);
         }
 
         // Get private key once
@@ -338,7 +338,7 @@ export class WorkerSigningPool {
             const errors = new Map<number, string>();
 
             for (let i = 0; i < batchResults.length; i++) {
-                const result = batchResults[i]!;
+                const result = batchResults[i] as PromiseSettledResult<BatchSigningResultMessage>;
                 if (result.status === 'fulfilled') {
                     const batchResult = result.value;
 
@@ -365,7 +365,7 @@ export class WorkerSigningPool {
                     const errorMsg = reason?.message ?? 'Batch signing failed';
 
                     // Add error for each task in the failed batch
-                    const failedBatch = taskBatches[i]!;
+                    const failedBatch = taskBatches[i] as SigningTask[];
                     for (const task of failedBatch) {
                         errors.set(task.inputIndex, errorMsg);
                     }

package/src/workers/psbt-parallel.ts

@@ -177,7 +177,7 @@ export function prepareSigningTasks(
     const pubkey = keyPair.publicKey;
 
     for (let i = 0; i < inputs.length; i++) {
-        const input = inputs[i]!;
+        const input = inputs[i] as PsbtInput;
 
         // Check if this input can be signed with this key
         if (!psbt.inputHasPubkey(i, pubkey as PublicKey)) {
@@ -285,7 +285,7 @@ export function applySignaturesToPsbt(
     const pubkey = keyPair.publicKey;
 
     for (const [inputIndex, sigResult] of result.signatures) {
-        const input = psbt.data.inputs[inputIndex]!;
+        const input = psbt.data.inputs[inputIndex] as PsbtInput;
 
         if (sigResult.signatureType === SignatureType.Schnorr) {
             // Taproot signature

package/test/address.spec.ts

@@ -66,6 +66,7 @@ describe('address', () => {
                 assert.strictEqual(actual.version, f.version);
                 // Support both bech32 and bech32Opnet prefixes
                 const network = NETWORKS[f.network];
+                assert.ok(network, `Unknown network: ${f.network}`);
                 const validPrefixes = [network.bech32, network.bech32Opnet].filter(Boolean);
                 assert.ok(
                     validPrefixes.includes(actual.prefix),

package/test/bitcoin.core.spec.ts

@@ -21,6 +21,7 @@ describe('Bitcoin-core', () => {
             const fb58 = f[1];
 
             it('can decode ' + fb58, () => {
+                assert(fb58 !== undefined);
                 const buffer = base58.decode(fb58);
                 const actual = toHex(new Uint8Array(buffer));
 
@@ -28,6 +29,7 @@ describe('Bitcoin-core', () => {
             });
 
             it('can encode ' + fhex, () => {
+                assert(fhex !== undefined);
                 const buffer = fromHex(fhex);
                 const actual = base58.encode(buffer);
 
@@ -78,6 +80,7 @@ describe('Bitcoin-core', () => {
             const strng = f[0];
 
             it('throws on ' + strng, () => {
+                assert(strng !== undefined);
                 assert.throws(() => {
                     const address = bitcoin.address.fromBase58Check(strng);
 
@@ -113,10 +116,12 @@ describe('Bitcoin-core', () => {
             //      const verifyFlags = f[2] // TODO: do we need to test this?
 
             it('can decode ' + fhex, () => {
+                assert(inputs !== undefined);
                 const transaction = bitcoin.Transaction.fromHex(fhex as string);
 
                 transaction.ins.forEach((txIn, i) => {
-                    const input = inputs[i];
+                    const input = (inputs as unknown[][])[i];
+                    assert(input !== undefined);
 
                     // reverse because test data is reversed
                     const prevOutHash = reverseCopy(fromHex(input[0] as string));
@@ -196,7 +201,9 @@ describe('Bitcoin-core', () => {
             if (i === 0) return;
             if (i % 2 !== 0) return;
 
-            const description = sigNoncanonical[i - 1].slice(0, -1);
+            const prev = sigNoncanonical[i - 1];
+            assert(prev !== undefined);
+            const description = prev.slice(0, -1);
             const buffer = fromHex(hex);
 
             it('throws on ' + description, () => {

package/test/browser/psbt.spec.ts

@@ -11,7 +11,7 @@ import { randomBytes } from './setup.js';
 import { convertScriptTree } from '../payments.utils.js';
 import { LEAF_VERSION_TAPSCRIPT } from '../../src/payments/bip341.js';
 import { tapTreeFromList, tapTreeToList } from '../../src/psbt/bip371.js';
-import type { Bytes32, EccLib, MessageHash, PrivateKey, PublicKey, Satoshi, Script, Signature, Taptree, } from '../../src/types.js';
+import type { Bytes32, EccLib, PrivateKey, PublicKey, Satoshi, Script, Signature, Taptree, } from '../../src/types.js';
 import type { HDSigner, Signer, SignerAsync, ValidateSigFunction } from '../../src/index.js';
 import { initEccLib, networks, payments, Psbt } from '../../src/index.js';
 import { equals } from '../../src/io/index.js';
@@ -19,6 +19,7 @@ import { equals } from '../../src/io/index.js';
 import preFixtures from '../fixtures/psbt.json' with { type: 'json' };
 import taprootFixtures from '../fixtures/p2tr.json' with { type: 'json' };
 import { ECPairSigner, createNobleBackend } from '@btc-vision/ecpair';
+import type { MessageHash } from '@btc-vision/ecpair';
 import type { Network } from '../../src/networks.js';
 
 const bip32 = BIP32Factory(ecc);
@@ -46,8 +47,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]!;
+        const encoding = result[2]!;
 
         return Buffer.from(data, encoding as BufferEncoding);
     });
@@ -59,7 +60,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 {
@@ -71,12 +72,12 @@ const toAsyncSigner = (signer: Signer): SignerAsync => {
                 }, 10);
             });
         },
-    };
+    } as unknown as SignerAsync;
 };
-const failedAsyncSigner = (publicKey: Buffer): SignerAsync => {
-    return <SignerAsync>{
+const failedAsyncSigner = (publicKey: Uint8Array): SignerAsync => {
+    return {
         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'));
@@ -181,10 +182,13 @@ 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);
 
-                assert.strictEqual(psbts[0].toHex(), Psbt.fromBase64(f.result).toHex());
+                assert.strictEqual(psbt0.toHex(), Psbt.fromBase64(f.result).toHex());
             });
         });
 
@@ -211,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'));
@@ -264,7 +270,7 @@ describe(`Psbt`, () => {
                     await assert.rejects(async () => {
                         await psbtThatShouldsign.signInputAsync(
                             f.shouldSign.inputToCheck,
-                            failedAsyncSigner(ECPair.fromWIF(f.shouldSign.WIF).publicKey),
+                            failedAsyncSigner(ECPair.fromWIF(f.shouldSign.WIF).publicKey as unknown as Buffer),
                             f.shouldSign.sighashTypes || undefined,
                         );
                     }, failMessage);
@@ -688,9 +694,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', () => {
@@ -844,6 +854,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"));
@@ -853,7 +866,7 @@ describe(`Psbt`, () => {
                     value: 1337n as Satoshi,
                     script: payments.p2sh({
                         redeem: { output: Buffer.from([0x51]) as unknown as Script },
-                    }).output!,
+                    }).output as Script,
                 },
             });
 
@@ -861,14 +874,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,
                 },
             });
 
@@ -876,7 +889,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([
@@ -1008,7 +1021,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,
@@ -1043,7 +1058,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());
@@ -1410,17 +1427,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,
                 ),
             );
@@ -1436,10 +1456,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');
         });
     });
 
@@ -1469,17 +1490,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);
@@ -1492,6 +1515,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);
@@ -1499,10 +1523,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/browser/workers-signing.spec.ts

@@ -83,7 +83,7 @@ describe('Worker Signing - Signature Verification', () => {
             const signature = ecc.sign(hash, keyPair.privateKey!);
 
             const modifiedHash = Buffer.from(hash);
-            modifiedHash[0] ^= 0xff;
+            modifiedHash[0]! ^= 0xff;
 
             const isValid = ecc.verify(modifiedHash, keyPair.publicKey, signature);
             expect(isValid).toBe(false);
@@ -95,7 +95,7 @@ describe('Worker Signing - Signature Verification', () => {
 
             const signature = Buffer.from(ecc.sign(hash, keyPair.privateKey!));
 
-            signature[0] ^= 0xff;
+            signature[0]! ^= 0xff;
 
             const isValid = ecc.verify(hash, keyPair.publicKey, signature);
             expect(isValid).toBe(false);
@@ -150,7 +150,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);
@@ -162,7 +162,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);
@@ -173,7 +173,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 => {
@@ -256,7 +256,7 @@ describe('Worker Signing - Signature Verification', () => {
             const signatures = hashes.map((hash) => ecc.sign(hash, keyPair.privateKey!));
 
             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);
             }
         });
 
@@ -325,7 +325,7 @@ describe('Worker Signing - Signature Verification', () => {
                 }
             });
 
-            const duration = Date.now() - startTime;
+            void (Date.now() - startTime);
 
             let validCount = 0;
             for (const result of results) {
@@ -406,7 +406,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/crypto.spec.ts

@@ -49,7 +49,7 @@ describe('crypto', () => {
 
             for (const key of storedKeys) {
                 assert.ok(
-                    equals(TAGGED_HASH_PREFIXES[key as TaggedHashPrefix], taggedHashPrefixes[key]),
+                    equals(TAGGED_HASH_PREFIXES[key as TaggedHashPrefix], taggedHashPrefixes[key] as Uint8Array),
                     `Mismatch for tag ${key}`,
                 );
             }

package/test/env.spec.ts

@@ -30,7 +30,7 @@ describe('Runtime capability check — hard requirements', () => {
 
     it('should throw when DataView.getBigInt64 is missing', async () => {
         const orig = DataView.prototype.getBigInt64;
-        (DataView.prototype as Record<string, unknown>)['getBigInt64'] = undefined;
+        (DataView.prototype as unknown as Record<string, unknown>)['getBigInt64'] = undefined;
 
         try {
             await import('../src/env.js');
@@ -261,7 +261,7 @@ describe('Polyfill — Promise.allSettled', () => {
 
     it('should polyfill Promise.allSettled when missing', async () => {
         const orig = Promise.allSettled;
-        (Promise as Record<string, unknown>)['allSettled'] = undefined;
+        (Promise as unknown as Record<string, unknown>)['allSettled'] = undefined;
 
         try {
             await import('../src/env.js');

package/test/integration/_regtest.ts

@@ -1,7 +1,7 @@
 import { RegtestUtils } from 'regtest-client';
 
-const APIPASS = process.env.APIPASS || 'satoshi';
-const APIURL = process.env.APIURL || 'https://regtest.bitbank.cc/1';
+const APIPASS = process.env['APIPASS'] || 'satoshi';
+const APIURL = process.env['APIURL'] || 'https://regtest.bitbank.cc/1';
 
 export const regtestUtils = new RegtestUtils({ APIPASS, APIURL });
 

package/test/integration/blocks.spec.ts

@@ -17,7 +17,7 @@ describe('bitcoinjs-lib (blocks)', () => {
         const tx = bitcoin.Transaction.fromHex(txHex);
 
         assert.strictEqual(tx.ins.length, 1);
-        const script = tx.ins[0].script;
+        const script = tx.ins[0]!.script;
         // bitcoin.script.decompile(script) // returns [] :(
 
         assert.strictEqual(script[0], 0x03);

package/test/integration/csv.spec.ts

@@ -403,7 +403,7 @@ function csvGetFinalScripts(
         output: script,
         // This logic should be more strict and make sure the pubkeys in the
         // meaningful script are the ones signing in the PSBT etc.
-        input: bitcoin.script.compile([input.partialSig![0].signature, bitcoin.opcodes.OP_TRUE]),
+        input: bitcoin.script.compile([input.partialSig![0]!.signature, bitcoin.opcodes.OP_TRUE]),
     };
     if (isP2WSH && isSegwit)
         payment = bitcoin.payments.p2wsh({