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

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({

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);
         });