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

package/src/psbt/PsbtSigner.ts

@@ -69,7 +69,8 @@ export class PsbtSigner {
                 this.#txFromBuffer,
             );
 
-            const prevoutHash = unsignedTx.ins[inputIndex]!.hash;
+            const txIn = unsignedTx.ins[inputIndex] as Transaction['ins'][0];
+            const prevoutHash = txIn.hash;
             const utxoHash = nonWitnessUtxoTx.getHash();
 
             if (!equals(prevoutHash, utxoHash)) {
@@ -78,8 +79,8 @@ export class PsbtSigner {
                 );
             }
 
-            const prevoutIndex = unsignedTx.ins[inputIndex]!.index;
-            prevout = nonWitnessUtxoTx.outs[prevoutIndex]!;
+            const prevoutIndex = txIn.index;
+            prevout = nonWitnessUtxoTx.outs[prevoutIndex] as Transaction['outs'][0];
         } else if (input.witnessUtxo) {
             prevout = {
                 script: input.witnessUtxo.script as Script,
@@ -108,7 +109,7 @@ export class PsbtSigner {
             if (!p2pkhPayment.output) throw new Error('Unable to create signing script');
             hash = unsignedTx.hashForWitnessV0(
                 inputIndex,
-                p2pkhPayment.output as Script,
+                p2pkhPayment.output,
                 prevout.value,
                 sighashType,
             );
@@ -198,7 +199,7 @@ export class PsbtSigner {
                     signingScripts,
                     values,
                     sighashType,
-                    tapLeaf.hash as Bytes32,
+                    tapLeaf.hash,
                     undefined,
                     taprootCache,
                 );
@@ -206,7 +207,7 @@ export class PsbtSigner {
                 return {
                     pubkey: pubkey as PublicKey,
                     hash: tapScriptHash,
-                    leafHash: tapLeaf.hash as Bytes32,
+                    leafHash: tapLeaf.hash,
                 };
             });
 

package/src/psbt/PsbtTransaction.ts

@@ -3,7 +3,7 @@ import { fromHex, reverse } from '../io/index.js';
 import { Transaction } from '../transaction.js';
 import type { Bytes32 } from '../types.js';
 import { checkTxEmpty } from './validation.js';
-import type { TransactionInput, TransactionOutput } from './types.js';
+import type { PsbtTxOutput, TransactionInput } from './types.js';
 
 /**
  * Empty version-2 transaction with zero inputs and zero outputs.
@@ -56,7 +56,7 @@ export class PsbtTransaction implements ITransaction {
         this.tx.addInput(hash, input.index, input.sequence);
     }
 
-    public addOutput(output: TransactionOutput): void {
+    public addOutput(output: PsbtTxOutput): void {
         if (
             output.script === undefined ||
             output.value === undefined ||

package/src/psbt/bip371.ts

@@ -180,10 +180,11 @@ export function tapTreeToList(tree: Taptree): TapLeaf[] {
  * @returns the corresponding taptree, or throws an exception if the tree cannot be reconstructed
  */
 export function tapTreeFromList(leaves: TapLeaf[] = []): Taptree {
-    if (leaves.length === 1 && leaves[0]!.depth === 0)
+    const firstLeaf = leaves[0];
+    if (leaves.length === 1 && firstLeaf && firstLeaf.depth === 0)
         return {
-            output: new Uint8Array(leaves[0]!.script),
-            version: leaves[0]!.leafVersion,
+            output: new Uint8Array(firstLeaf.script),
+            version: firstLeaf.leafVersion,
         };
 
     return insertLeavesInTree(leaves);

package/src/psbt/utils.ts

@@ -73,7 +73,7 @@ export function sighashTypeToString(sighashType: number): string {
  */
 export function compressPubkey(pubkey: Uint8Array): Uint8Array {
     if (pubkey.length === 65) {
-        const parity = pubkey[64]! & 1;
+        const parity = (pubkey[64] as number) & 1;
         const newKey = new Uint8Array(pubkey.subarray(0, 33));
         newKey[0] = 2 | parity;
         return newKey;

package/src/psbt.ts

@@ -3,6 +3,7 @@ import type {
     PsbtGlobalUpdate,
     PsbtInput,
     PsbtInputUpdate,
+    PsbtOutput,
     PsbtOutputUpdate,
     TapKeySig,
     TapScriptSig,
@@ -79,6 +80,7 @@ export type {
     PsbtInputExtended,
     PsbtOutputExtended,
     PsbtOutputExtendedScript,
+    PsbtOutputExtendedAddress,
     HDSigner,
     HDSignerAsync,
     Signer,
@@ -348,7 +350,7 @@ export class Psbt {
         if (this.#cache.tx.ins.length <= inputIndex) {
             throw new Error('Input index too high');
         }
-        this.#cache.tx.ins[inputIndex]!.sequence = sequence;
+        (this.#cache.tx.ins[inputIndex] as { sequence: number }).sequence = sequence;
         this.#cache.invalidate('outputs');
         return this;
     }
@@ -386,11 +388,11 @@ export class Psbt {
               }
             : inputData;
         this.data.addInput(normalizedInputData);
-        const txIn = this.#cache.tx.ins[this.#cache.tx.ins.length - 1]!;
+        const txIn = this.#cache.tx.ins[this.#cache.tx.ins.length - 1] as Transaction['ins'][0];
         checkTxInputCache(this.#cache, txIn);
 
         const inputIndex = this.data.inputs.length - 1;
-        const input = this.data.inputs[inputIndex]!;
+        const input = this.data.inputs[inputIndex] as PsbtInput;
         if (input.nonWitnessUtxo) {
             this.#cache.addNonWitnessTxCache(input, inputIndex, txFromBuffer);
         }
@@ -558,7 +560,7 @@ export class Psbt {
         validator: ValidateSigFunction,
         pubkey?: PublicKey,
     ): boolean {
-        const input = this.data.inputs[inputIndex]!;
+        const input = this.data.inputs[inputIndex] as PsbtInput;
         if (isTaprootInput(input))
             return this.#validateSignaturesOfTaprootInput(inputIndex, validator, pubkey);
 
@@ -795,7 +797,7 @@ export class Psbt {
 
     public updateInput(inputIndex: number, updateData: PsbtInputUpdate): this {
         if (updateData.witnessScript) checkInvalidP2WSH(updateData.witnessScript);
-        checkTaprootInputFields(this.data.inputs[inputIndex]!, updateData, 'updateInput');
+        checkTaprootInputFields(this.data.inputs[inputIndex] as PsbtInput, updateData, 'updateInput');
         const normalizedUpdate = updateData.witnessUtxo
             ? {
                   ...updateData,
@@ -811,7 +813,7 @@ export class Psbt {
         this.data.updateInput(inputIndex, normalizedUpdate);
         if (updateData.nonWitnessUtxo) {
             this.#cache.addNonWitnessTxCache(
-                this.data.inputs[inputIndex]!,
+                this.data.inputs[inputIndex] as PsbtInput,
                 inputIndex,
                 txFromBuffer,
             );
@@ -820,7 +822,7 @@ export class Psbt {
     }
 
     public updateOutput(outputIndex: number, updateData: PsbtOutputUpdate): this {
-        const outputData = this.data.outputs[outputIndex]!;
+        const outputData = this.data.outputs[outputIndex] as PsbtOutput;
         checkTaprootOutputFields(outputData, updateData, 'updateOutput');
 
         this.data.updateOutput(outputIndex, updateData);
@@ -986,7 +988,7 @@ export class Psbt {
         validator: ValidateSigFunction,
         pubkey?: PublicKey,
     ): boolean {
-        const input = this.data.inputs[inputIndex]!;
+        const input = this.data.inputs[inputIndex] as PsbtInput;
         const tapKeySig = input?.tapKeySig;
         const tapScriptSig = input?.tapScriptSig;
         if (!input && !tapKeySig && !(tapScriptSig && !tapScriptSig.length))
@@ -1049,7 +1051,7 @@ export class Psbt {
             sighashTypes,
         );
 
-        const sig = keyPair.sign(hash) as Uint8Array;
+        const sig = keyPair.sign(hash);
         const partialSig = [
             {
                 pubkey,

package/src/push_data.ts

@@ -61,19 +61,19 @@ export function decode(
     size: number;
 } | null {
     const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-    const opcode = buffer[offset];
+    const opcode = buffer[offset] as number;
     let num: number;
     let size: number;
 
     // ~6 bit
-    if (opcode! < opcodes.OP_PUSHDATA1) {
-        num = opcode!;
+    if (opcode < opcodes.OP_PUSHDATA1) {
+        num = opcode;
         size = 1;
 
         // 8 bit
     } else if (opcode === opcodes.OP_PUSHDATA1) {
         if (offset + 2 > buffer.length) return null;
-        num = buffer[offset + 1]!;
+        num = buffer[offset + 1] as number;
         size = 2;
 
         // 16 bit
@@ -92,7 +92,7 @@ export function decode(
     }
 
     return {
-        opcode: opcode!,
+        opcode,
         number: num,
         size,
     };

package/src/react-native-quick-crypto.d.ts

@@ -0,0 +1,11 @@
+declare module 'react-native-quick-crypto' {
+    interface Hash {
+        update(data: Uint8Array | string): Hash;
+        digest(): Buffer;
+    }
+    interface QuickCrypto {
+        createHash(algorithm: string): Hash;
+    }
+    const QuickCrypto: QuickCrypto;
+    export default QuickCrypto;
+}

package/src/script.ts

@@ -41,8 +41,9 @@ export function countNonPushOnlyOPs(value: Stack): number {
 function asMinimalOP(buffer: Uint8Array): number | undefined {
     if (buffer.length === 0) return opcodes.OP_0;
     if (buffer.length !== 1) return undefined;
-    if (buffer[0]! >= 1 && buffer[0]! <= 16) return OP_INT_BASE + buffer[0]!;
-    if (buffer[0] === 0x81) return opcodes.OP_1NEGATE;
+    const firstByte = buffer[0] as number;
+    if (firstByte >= 1 && firstByte <= 16) return OP_INT_BASE + firstByte;
+    if (firstByte === 0x81) return opcodes.OP_1NEGATE;
     return undefined;
 }
 
@@ -129,7 +130,7 @@ export function decompile(buffer: Uint8Array | Stack): Array<number | Uint8Array
     let i = 0;
 
     while (i < buffer.length) {
-        const opcode = buffer[i]!;
+        const opcode = buffer[i] as number;
 
         // data chunk
         if (opcode > opcodes.OP_0 && opcode <= opcodes.OP_PUSHDATA4) {
@@ -248,7 +249,7 @@ export function isCanonicalPubKey(buffer: Uint8Array): boolean {
 
 export function isCanonicalScriptSignature(buffer: Uint8Array): boolean {
     if (!(buffer instanceof Uint8Array)) return false;
-    if (!isDefinedHashType(buffer[buffer.length - 1]!)) return false;
+    if (!isDefinedHashType(buffer[buffer.length - 1] as number)) return false;
 
     return bip66.check(buffer.subarray(0, -1));
 }

package/src/script_number.ts

@@ -16,8 +16,8 @@ export function decode(buffer: Buffer, maxLength?: number, minimal?: boolean): n
     if (length === 0) return 0;
     if (length > maxLength) throw new TypeError('Script number overflow');
     if (minimal) {
-        if ((buffer[length - 1]! & 0x7f) === 0) {
-            if (length <= 1 || (buffer[length - 2]! & 0x80) === 0)
+        if (((buffer[length - 1] as number) & 0x7f) === 0) {
+            if (length <= 1 || ((buffer[length - 2] as number) & 0x80) === 0)
                 throw new Error('Non-minimally encoded script number');
         }
     }
@@ -34,10 +34,10 @@ export function decode(buffer: Buffer, maxLength?: number, minimal?: boolean): n
     // 32-bit / 24-bit / 16-bit / 8-bit
     let result = 0;
     for (let i = 0; i < length; ++i) {
-        result |= buffer[i]! << (8 * i);
+        result |= (buffer[i] as number) << (8 * i);
     }
 
-    if (buffer[length - 1]! & 0x80) return -(result & ~(0x80 << (8 * (length - 1))));
+    if ((buffer[length - 1] as number) & 0x80) return -(result & ~(0x80 << (8 * (length - 1))));
     return result;
 }
 
@@ -62,10 +62,10 @@ export function encode(_number: number): Buffer {
         value >>= 8;
     }
 
-    if (buffer[size - 1]! & 0x80) {
+    if ((buffer[size - 1] as number) & 0x80) {
         buffer.writeUInt8(negative ? 0x80 : 0x00, size - 1);
     } else if (negative) {
-        buffer[size - 1]! |= 0x80;
+        buffer[size - 1] = (buffer[size - 1] as number) | 0x80;
     }
 
     return buffer;

package/src/script_signature.ts

@@ -24,7 +24,7 @@ function toDER(x: Uint8Array): Uint8Array {
     while (x[i] === 0) ++i;
     if (i === x.length) return ZERO;
     x = x.subarray(i);
-    if (x[0]! & 0x80) return concat([ZERO, x]);
+    if ((x[0] as number) & 0x80) return concat([ZERO, x]);
     return x;
 }
 
@@ -56,7 +56,7 @@ export interface ScriptSignature {
  * @throws Error if the hashType is invalid.
  */
 export function decode(buffer: Uint8Array): ScriptSignature {
-    const hashType = buffer[buffer.length - 1]!;
+    const hashType = buffer[buffer.length - 1] as number;
     if (!isDefinedHashType(hashType)) {
         throw new Error(`Invalid hashType ${hashType}`);
     }

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);
@@ -770,7 +771,7 @@ export class Transaction {
     getHash(forWitness?: boolean): Bytes32 {
         // wtxid for coinbase is always 32 bytes of 0x00
         if (forWitness && this.isCoinbase()) return new Uint8Array(32) as Bytes32;
-        return bcrypto.hash256(this.#toBuffer(undefined, undefined, forWitness)) as Bytes32;
+        return bcrypto.hash256(this.#toBuffer(undefined, undefined, forWitness));
     }
 
     /**
@@ -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/index.ts

@@ -57,7 +57,7 @@ export * from './index.shared.js';
  * @returns 'node' for Node.js, 'browser' for browsers, 'unknown' otherwise
  */
 export function detectRuntime(): 'node' | 'browser' | 'react-native' | 'unknown' {
-    if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
+    if (typeof navigator !== 'undefined' && (navigator as {product?: string}).product === 'ReactNative') {
         return 'react-native';
     }
     if (typeof process !== 'undefined' && process.versions?.node) {

package/src/workers/psbt-parallel.ts

@@ -118,7 +118,7 @@ export async function signPsbtParallel(
         pool = poolOrConfig;
     } else {
         const { WorkerSigningPool } = await import('./WorkerSigningPool.js');
-        pool = WorkerSigningPool.getInstance(poolOrConfig as WorkerPoolConfig | undefined);
+        pool = WorkerSigningPool.getInstance(poolOrConfig);
         if (!pool.isPreservingWorkers) {
             shouldShutdown = true;
         }
@@ -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, () => {