@btc-vision/bitcoin 7.0.0-alpha.1 → 7.0.0-alpha.10

package/test/psbt.spec.ts

@@ -2,25 +2,36 @@ import assert from 'assert';
 import { BIP32Factory } from '@btc-vision/bip32';
 import * as ecc from 'tiny-secp256k1';
 import * as crypto from 'crypto';
-import { ECPairFactory } from 'ecpair';
 import { beforeEach, describe, it } from 'vitest';
 
 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 { Taptree, Bytes32, Script, Satoshi, PublicKey, Signature, EccLib } from '../src/types.js';
-import { initEccLib, networks as NETWORKS, payments, Psbt } from '../src/index.js';
-import type { Signer, SignerAsync, HDSigner, HDSignerAsync, ValidateSigFunction } from '../src/index.js';
+import type { Bytes32, EccLib, MessageHash, 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';
 
 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 { Network } from '../src/networks.js';
 
 const bip32 = BIP32Factory(ecc);
-const ECPair = ECPairFactory(ecc);
+const backend = createNobleBackend();
+const ECPair = {
+    makeRandom: (opts?: { network?: Network }) =>
+        ECPairSigner.makeRandom(backend, opts?.network ?? networks.bitcoin),
+    fromWIF: (wif: string, network?: Network | Network[]) =>
+        ECPairSigner.fromWIF(backend, wif, network ?? networks.bitcoin),
+    fromPublicKey: (pubkey: Uint8Array, opts?: { network?: Network }) =>
+        ECPairSigner.fromPublicKey(backend, pubkey as PublicKey, opts?.network ?? networks.bitcoin),
+    fromPrivateKey: (key: Uint8Array, opts?: { network?: Network }) =>
+        ECPairSigner.fromPrivateKey(backend, key as PrivateKey, opts?.network ?? networks.bitcoin),
+};
 
 const validator: ValidateSigFunction = (pubkey, msghash, signature): boolean =>
-    ECPair.fromPublicKey(pubkey).verify(msghash, signature);
+    ECPair.fromPublicKey(pubkey).verify(msghash, signature as Signature);
 
 const schnorrValidator: ValidateSigFunction = (pubkey, msghash, signature): boolean =>
     ecc.verifySchnorr(msghash, pubkey, signature);
@@ -146,7 +157,7 @@ describe(`Psbt`, () => {
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                 // @ts-ignore // cannot find tapLeafHashToSign
                 f.keys.forEach(({ inputToSign, tapLeafHashToSign, WIF }) => {
-                    const keyPair = ECPair.fromWIF(WIF, NETWORKS.testnet);
+                    const keyPair = ECPair.fromWIF(WIF, networks.testnet);
                     if (tapLeafHashToSign)
                         psbt.signTaprootInput(
                             inputToSign,
@@ -509,7 +520,10 @@ describe(`Psbt`, () => {
             const f = fixtures.finalizeInput.finalizeTapleafByHash;
             const psbt = Psbt.fromBase64(f.psbt);
 
-            psbt.finalizeTaprootInput(f.index, Buffer.from(f.leafHash, 'hex') as unknown as Bytes32);
+            psbt.finalizeTaprootInput(
+                f.index,
+                Buffer.from(f.leafHash, 'hex') as unknown as Bytes32,
+            );
 
             assert.strictEqual(psbt.toBase64(), f.result);
         });
@@ -519,7 +533,10 @@ describe(`Psbt`, () => {
             const psbt = Psbt.fromBase64(f.psbt);
 
             assert.throws(() => {
-                psbt.finalizeTaprootInput(f.index, Buffer.from(f.leafHash, 'hex').reverse() as unknown as Bytes32);
+                psbt.finalizeTaprootInput(
+                    f.index,
+                    Buffer.from(f.leafHash, 'hex').reverse() as unknown as Bytes32,
+                );
             }, new RegExp('Can not finalize taproot input #0. Signature for tapleaf script not found.'));
         });
 
@@ -557,7 +574,10 @@ describe(`Psbt`, () => {
             }, new RegExp('No script found for input #0'));
             psbt.updateInput(0, {
                 witnessUtxo: {
-                    script: Buffer.from('0014d85c2b71d0060b09c9886aeb815e50991dda124d', 'hex') as unknown as Script,
+                    script: Buffer.from(
+                        '0014d85c2b71d0060b09c9886aeb815e50991dda124d',
+                        'hex',
+                    ) as unknown as Script,
                     value: 200000n as Satoshi,
                 },
             });
@@ -730,7 +750,10 @@ describe(`Psbt`, () => {
                 ...(redeemGetter ? { redeemScript: redeemGetter(publicKey) } : {}),
                 ...(witnessGetter ? { witnessScript: witnessGetter(publicKey) } : {}),
             }).addOutput({
-                script: Buffer.from('0014d85c2b71d0060b09c9886aeb815e50991dda124d', 'hex') as unknown as Script,
+                script: Buffer.from(
+                    '0014d85c2b71d0060b09c9886aeb815e50991dda124d',
+                    'hex',
+                ) as unknown as Script,
                 value: 1800n as Satoshi,
             });
             if (finalize) psbt.signInput(0, key).finalizeInput(0);
@@ -904,7 +927,10 @@ describe(`Psbt`, () => {
                 hash: '0000000000000000000000000000000000000000000000000000000000000000',
                 index: 0,
             }).addOutput({
-                script: Buffer.from('0014000102030405060708090a0b0c0d0e0f00010203', 'hex') as unknown as Script,
+                script: Buffer.from(
+                    '0014000102030405060708090a0b0c0d0e0f00010203',
+                    'hex',
+                ) as unknown as Script,
                 value: 2000n as Satoshi,
                 bip32Derivation: [
                     {
@@ -936,7 +962,9 @@ describe(`Psbt`, () => {
                 index: 0,
             }).addOutput({
                 script: payments.p2sh({
-                    redeem: { output: Buffer.from([0x51]) as unknown as Script },
+                    redeem: payments.p2wsh({
+                        redeem: { output: scriptWithPubkey as unknown as Script },
+                    }),
                 }).output!,
                 value: 1337n as Satoshi,
             });
@@ -945,31 +973,45 @@ describe(`Psbt`, () => {
                 psbt.outputHasPubkey(0, testPubkey);
             }, new RegExp('scriptPubkey is P2SH but redeemScript missing'));
 
-            (psbt as any).__CACHE.tx.outs[0].script = payments.p2wsh({
-                redeem: { output: Buffer.from([0x51]) as unknown as Script },
-            }).output!;
+            const psbt2 = new Psbt();
+            psbt2.addInput({
+                hash: '0000000000000000000000000000000000000000000000000000000000000000',
+                index: 0,
+            }).addOutput({
+                script: payments.p2wsh({
+                    redeem: { output: Buffer.from([0x51]) as unknown as Script },
+                }).output!,
+                value: 1337n as Satoshi,
+            });
 
             assert.throws(() => {
-                psbt.outputHasPubkey(0, testPubkey);
+                psbt2.outputHasPubkey(0, testPubkey);
             }, new RegExp('scriptPubkey or redeemScript is P2WSH but witnessScript missing'));
 
-            (psbt as any).__CACHE.tx.outs[0].script = payments.p2sh({
-                redeem: payments.p2wsh({
-                    redeem: { output: scriptWithPubkey as unknown as Script },
-                }),
-            }).output!;
+            const psbt3 = new Psbt();
+            psbt3.addInput({
+                hash: '0000000000000000000000000000000000000000000000000000000000000000',
+                index: 0,
+            }).addOutput({
+                script: payments.p2sh({
+                    redeem: payments.p2wsh({
+                        redeem: { output: scriptWithPubkey as unknown as Script },
+                    }),
+                }).output!,
+                value: 1337n as Satoshi,
+            });
 
-            psbt.updateOutput(0, {
+            psbt3.updateOutput(0, {
                 redeemScript: payments.p2wsh({
                     redeem: { output: scriptWithPubkey as unknown as Script },
                 }).output!,
             });
 
             assert.throws(() => {
-                psbt.outputHasPubkey(0, testPubkey);
+                psbt3.outputHasPubkey(0, testPubkey);
             }, new RegExp('scriptPubkey or redeemScript is P2WSH but witnessScript missing'));
 
-            delete psbt.data.outputs[0].redeemScript;
+            delete psbt3.data.outputs[0].redeemScript;
 
             psbt.updateOutput(0, {
                 witnessScript: scriptWithPubkey,
@@ -1003,7 +1045,8 @@ describe(`Psbt`, () => {
             assert.strictEqual(clone.toBase64(), psbt.toBase64());
             assert.strictEqual(clone.toBase64(), notAClone.toBase64());
             assert.strictEqual(psbt.toBase64(), notAClone.toBase64());
-            (psbt as any).__CACHE.tx.version |= 0xff0000;
+            // Mutate data layer to prove clone is independent
+            psbt.data.inputs[0].partialSig = [];
             assert.notStrictEqual(clone.toBase64(), psbt.toBase64());
             assert.notStrictEqual(clone.toBase64(), notAClone.toBase64());
             assert.strictEqual(psbt.toBase64(), notAClone.toBase64());
@@ -1014,9 +1057,9 @@ describe(`Psbt`, () => {
         it('Sets the maximumFeeRate value', () => {
             const psbt = new Psbt();
 
-            assert.strictEqual((psbt as any).opts.maximumFeeRate, 5000);
+            assert.strictEqual(psbt.maximumFeeRate, 5000);
             psbt.setMaximumFeeRate(6000);
-            assert.strictEqual((psbt as any).opts.maximumFeeRate, 6000);
+            assert.strictEqual(psbt.maximumFeeRate, 6000);
         });
     });
 
@@ -1154,11 +1197,149 @@ describe(`Psbt`, () => {
             psbt.finalizeAllInputs();
 
             assert.strictEqual(psbt.getFeeRate(), f.fee);
-            (psbt as any).__CACHE.feeRate = undefined;
+            // Calling again returns the same cached value
             assert.strictEqual(psbt.getFeeRate(), f.fee);
         });
     });
 
+    describe('getFee and getFeeRate return correct values', () => {
+        it('computes fee as inputAmount - outputAmount for nonWitnessUtxo', () => {
+            // nonWitnessUtxo output[0] = 90,000 sats; we send 80,000 sats => fee = 10,000 sats
+            const alice = ECPair.fromWIF('L2uPYXe17xSTqbCjZvL2DsyXPCbXspvcu5mHLDYUgzdUbZGSKrSr');
+            const psbt = new Psbt();
+            const inputValue = 90_000n;
+            const outputValue = 80_000n as Satoshi;
+
+            psbt.addInput({
+                hash: '7d067b4a697a09d2c3cff7d4d9506c9955e93bff41bf82d439da7d030382bc3e',
+                index: 0,
+                nonWitnessUtxo: Buffer.from(
+                    '0200000001f9f34e95b9d5c8abcd20fc5bd4a825d1517be62f0f775e5f36da944d9' +
+                        '452e550000000006b483045022100c86e9a111afc90f64b4904bd609e9eaed80d48' +
+                        'ca17c162b1aca0a788ac3526f002207bb79b60d4fc6526329bf18a77135dc566020' +
+                        '9e761da46e1c2f1152ec013215801210211755115eabf846720f5cb18f248666fec' +
+                        '631e5e1e66009ce3710ceea5b1ad13ffffffff01905f0100000000001976a9148bb' +
+                        'c95d2709c71607c60ee3f097c1217482f518d88ac00000000',
+                    'hex',
+                ),
+                sighashType: 1,
+            });
+            psbt.addOutput({
+                address: '1KRMKfeZcmosxALVYESdPNez1AP1mEtywp',
+                value: outputValue,
+            });
+            psbt.signInput(0, alice);
+            psbt.finalizeAllInputs();
+
+            const expectedFee = Number(inputValue - outputValue); // 10,000
+            const fee = psbt.getFee();
+            assert.strictEqual(fee, expectedFee, `fee should be ${expectedFee}, got ${fee}`);
+
+            const tx = psbt.extractTransaction(true);
+            const vsize = tx.virtualSize();
+            const expectedFeeRate = Math.floor(expectedFee / vsize);
+            const feeRate = psbt.getFeeRate();
+            assert.strictEqual(
+                feeRate,
+                expectedFeeRate,
+                `feeRate should be fee/vsize = ${expectedFee}/${vsize} = ${expectedFeeRate}, got ${feeRate}`,
+            );
+        });
+
+        it('computes fee as inputAmount - outputAmount for witnessUtxo', () => {
+            const alice = ECPair.fromWIF('L2uPYXe17xSTqbCjZvL2DsyXPCbXspvcu5mHLDYUgzdUbZGSKrSr');
+            const p2wpkh = payments.p2wpkh({ pubkey: alice.publicKey as PublicKey });
+            const inputValue = 50_000n;
+            const outputValue = 40_000n as Satoshi;
+
+            const psbt = new Psbt();
+            psbt.addInput({
+                hash: '0000000000000000000000000000000000000000000000000000000000000001',
+                index: 0,
+                witnessUtxo: {
+                    script: p2wpkh.output! as Script,
+                    value: inputValue as Satoshi,
+                },
+            });
+            psbt.addOutput({
+                address: '1KRMKfeZcmosxALVYESdPNez1AP1mEtywp',
+                value: outputValue,
+            });
+            psbt.signInput(0, alice);
+            psbt.finalizeAllInputs();
+
+            const expectedFee = Number(inputValue - outputValue); // 10,000
+            const fee = psbt.getFee();
+            assert.strictEqual(fee, expectedFee, `fee should be ${expectedFee}, got ${fee}`);
+
+            const tx = psbt.extractTransaction(true);
+            const vsize = tx.virtualSize();
+            const expectedFeeRate = Math.floor(expectedFee / vsize);
+            const feeRate = psbt.getFeeRate();
+            assert.strictEqual(
+                feeRate,
+                expectedFeeRate,
+                `feeRate should be fee/vsize = ${expectedFee}/${vsize} = ${expectedFeeRate}, got ${feeRate}`,
+            );
+            assert.ok(feeRate > 0, 'feeRate must be positive');
+        });
+
+        it('computes fee correctly with multiple inputs and outputs', () => {
+            const alice = ECPair.fromWIF('L2uPYXe17xSTqbCjZvL2DsyXPCbXspvcu5mHLDYUgzdUbZGSKrSr');
+            const p2wpkh = payments.p2wpkh({ pubkey: alice.publicKey as PublicKey });
+
+            const input1Value = 30_000n;
+            const input2Value = 25_000n;
+            const output1Value = 20_000n as Satoshi;
+            const output2Value = 15_000n as Satoshi;
+
+            const psbt = new Psbt();
+            psbt.addInput({
+                hash: '0000000000000000000000000000000000000000000000000000000000000001',
+                index: 0,
+                witnessUtxo: {
+                    script: p2wpkh.output! as Script,
+                    value: input1Value as Satoshi,
+                },
+            });
+            psbt.addInput({
+                hash: '0000000000000000000000000000000000000000000000000000000000000002',
+                index: 0,
+                witnessUtxo: {
+                    script: p2wpkh.output! as Script,
+                    value: input2Value as Satoshi,
+                },
+            });
+            psbt.addOutput({
+                address: '1KRMKfeZcmosxALVYESdPNez1AP1mEtywp',
+                value: output1Value,
+            });
+            psbt.addOutput({
+                address: '1KRMKfeZcmosxALVYESdPNez1AP1mEtywp',
+                value: output2Value,
+            });
+            psbt.signAllInputs(alice);
+            psbt.finalizeAllInputs();
+
+            const totalIn = input1Value + input2Value; // 55,000
+            const totalOut = output1Value + output2Value; // 35,000
+            const expectedFee = Number(totalIn - totalOut); // 20,000
+            const fee = psbt.getFee();
+            assert.strictEqual(fee, expectedFee, `fee should be ${expectedFee}, got ${fee}`);
+
+            const tx = psbt.extractTransaction(true);
+            const vsize = tx.virtualSize();
+            const expectedFeeRate = Math.floor(expectedFee / vsize);
+            const feeRate = psbt.getFeeRate();
+            assert.strictEqual(
+                feeRate,
+                expectedFeeRate,
+                `feeRate should be ${expectedFee}/${vsize} = ${expectedFeeRate}, got ${feeRate}`,
+            );
+            assert.ok(feeRate > 0, 'feeRate must be positive');
+        });
+    });
+
     describe('create 1-to-1 transaction', () => {
         it('creates and signs a 1-to-1 transaction correctly', () => {
             const alice = ECPair.fromWIF('L2uPYXe17xSTqbCjZvL2DsyXPCbXspvcu5mHLDYUgzdUbZGSKrSr');
@@ -1213,49 +1394,56 @@ describe(`Psbt`, () => {
                 ),
             );
             assert.strictEqual(psbt instanceof Psbt, true);
-            assert.ok((psbt as any).__CACHE.tx);
+            assert.strictEqual(typeof psbt.version, 'number');
         });
         it('fromBase64 returns Psbt type (not base class)', () => {
             const psbt = Psbt.fromBase64('cHNidP8BAAoBAAAAAAAAAAAAAAAA');
             assert.strictEqual(psbt instanceof Psbt, true);
-            assert.ok((psbt as any).__CACHE.tx);
+            assert.strictEqual(typeof psbt.version, 'number');
         });
         it('fromHex returns Psbt type (not base class)', () => {
             const psbt = Psbt.fromHex('70736274ff01000a01000000000000000000000000');
             assert.strictEqual(psbt instanceof Psbt, true);
-            assert.ok((psbt as any).__CACHE.tx);
+            assert.strictEqual(typeof psbt.version, 'number');
         });
     });
 
     describe('Cache', () => {
-        it('non-witness UTXOs are cached', () => {
+        it('non-witness UTXOs are stored after updateInput', () => {
             const f = fixtures.cache.nonWitnessUtxo;
             const psbt = Psbt.fromBase64(f.psbt);
             const index = f.inputIndex;
 
-            // Cache is empty
-            assert.strictEqual(
-                (psbt as any).__CACHE.nonWitnessUtxoBufCache[index],
-                undefined,
-            );
+            // nonWitnessUtxo is not set before updateInput
+            assert.strictEqual(psbt.data.inputs[index].nonWitnessUtxo, undefined);
 
-            // Cache is populated
+            // After updateInput, the nonWitnessUtxo is stored on the input
             psbt.updateInput(index, {
                 nonWitnessUtxo: f.nonWitnessUtxo as any,
             });
-            const value = psbt.data.inputs[index].nonWitnessUtxo;
-            assert.ok(equals((psbt as any).__CACHE.nonWitnessUtxoBufCache[index], value));
+            assert.ok(psbt.data.inputs[index].nonWitnessUtxo);
             assert.ok(
                 equals(
-                    (psbt as any).__CACHE.nonWitnessUtxoBufCache[index],
+                    psbt.data.inputs[index].nonWitnessUtxo!,
                     f.nonWitnessUtxo as any,
                 ),
             );
+        });
+
+        it('nonWitnessUtxo remains a plain data property (no defineProperty)', () => {
+            const f = fixtures.cache.nonWitnessUtxo;
+            const psbt = Psbt.fromBase64(f.psbt);
+            const index = f.inputIndex;
 
-            // Cache is rebuilt from internal transaction object when cleared
-            psbt.data.inputs[index].nonWitnessUtxo = new Uint8Array([1, 2, 3]);
-            (psbt as any).__CACHE.nonWitnessUtxoBufCache[index] = undefined;
-            assert.ok(equals((psbt as any).data.inputs[index].nonWitnessUtxo!, value!));
+            psbt.updateInput(index, {
+                nonWitnessUtxo: f.nonWitnessUtxo as any,
+            });
+
+            const input = psbt.data.inputs[index];
+            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');
         });
     });
 
@@ -1264,22 +1452,18 @@ describe(`Psbt`, () => {
             const psbt = new Psbt();
 
             assert.strictEqual(psbt.version, 2);
-            assert.strictEqual(psbt.version, (psbt as any).__CACHE.tx.version);
 
             psbt.version = 1;
             assert.strictEqual(psbt.version, 1);
-            assert.strictEqual(psbt.version, (psbt as any).__CACHE.tx.version);
         });
 
         it('.locktime is exposed and is settable', () => {
             const psbt = new Psbt();
 
             assert.strictEqual(psbt.locktime, 0);
-            assert.strictEqual(psbt.locktime, (psbt as any).__CACHE.tx.locktime);
 
             psbt.locktime = 123;
             assert.strictEqual(psbt.locktime, 123);
-            assert.strictEqual(psbt.locktime, (psbt as any).__CACHE.tx.locktime);
         });
 
         it('.txInputs is exposed as a readonly clone', () => {
@@ -1289,19 +1473,20 @@ describe(`Psbt`, () => {
             psbt.addInput({ hash, index });
 
             const input = psbt.txInputs[0];
-            const internalInput = (psbt as any).__CACHE.tx.ins[0];
-
-            assert.ok(equals(input.hash, internalInput.hash));
-            assert.strictEqual(input.index, internalInput.index);
-            assert.strictEqual(input.sequence, internalInput.sequence);
+            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;
 
-            assert.ok(!equals(input.hash, internalInput.hash));
-            assert.notEqual(input.index, internalInput.index);
-            assert.notEqual(input.sequence, internalInput.sequence);
+            // Internal state should be unchanged
+            const fresh = psbt.txInputs[0];
+            assert.ok(equals(fresh.hash, originalHash));
+            assert.strictEqual(fresh.index, originalIndex);
+            assert.strictEqual(fresh.sequence, originalSequence);
         });
 
         it('.txOutputs is exposed as a readonly clone', () => {
@@ -1311,18 +1496,19 @@ describe(`Psbt`, () => {
             psbt.addOutput({ address, value });
 
             const output = psbt.txOutputs[0];
-            const internalInput = (psbt as any).__CACHE.tx.outs[0];
-
             assert.strictEqual(output.address, address);
 
-            assert.ok(equals(output.script, internalInput.script));
-            assert.strictEqual(output.value, internalInput.value);
+            const originalScript = new Uint8Array(output.script);
+            const originalValue = output.value;
 
+            // Mutate the returned clone
             output.script[0] = 123;
             output.value = 123n;
 
-            assert.ok(!equals(output.script, internalInput.script));
-            assert.notEqual(output.value, internalInput.value);
+            // Internal state should be unchanged
+            const fresh = psbt.txOutputs[0];
+            assert.ok(equals(fresh.script, originalScript));
+            assert.strictEqual(fresh.value, originalValue);
         });
     });
 });

package/test/script_signature.spec.ts

@@ -1,7 +1,7 @@
 import assert from 'assert';
 import { describe, it } from 'vitest';
 import { signature as bscriptSig } from '../src/script.js';
-import { toHex, fromHex, concat } from '../src/io/index.js';
+import { concat, fromHex, toHex } from '../src/io/index.js';
 import fixtures from './fixtures/signature.json' with { type: 'json' };
 
 describe('Script Signatures', () => {

package/test/transaction.spec.ts

@@ -2,7 +2,7 @@ import assert from 'assert';
 import { beforeEach, describe, it } from 'vitest';
 import { Transaction } from '../src/index.js';
 import * as bscript from '../src/script.js';
-import type { Bytes32, Script, Satoshi } from '../src/types.js';
+import type { Bytes32, Satoshi, Script } from '../src/types.js';
 import fixtures from './fixtures/transaction.json' with { type: 'json' };
 
 describe('Transaction', () => {
@@ -189,8 +189,14 @@ describe('Transaction', () => {
     describe('addOutput', () => {
         it('returns an index', () => {
             const tx = new Transaction();
-            assert.strictEqual(tx.addOutput(Buffer.alloc(0) as unknown as Script, 0n as Satoshi), 0);
-            assert.strictEqual(tx.addOutput(Buffer.alloc(0) as unknown as Script, 0n as Satoshi), 1);
+            assert.strictEqual(
+                tx.addOutput(Buffer.alloc(0) as unknown as Script, 0n as Satoshi),
+                0,
+            );
+            assert.strictEqual(
+                tx.addOutput(Buffer.alloc(0) as unknown as Script, 0n as Satoshi),
+                1,
+            );
         });
     });
 
@@ -293,7 +299,12 @@ describe('Transaction', () => {
                     const tx = Transaction.fromHex(f.txHex);
                     const script = bscript.fromASM(f.script);
 
-                    const hash = tx.hashForWitnessV0(f.inIndex, script, BigInt(f.value) as Satoshi, f.type);
+                    const hash = tx.hashForWitnessV0(
+                        f.inIndex,
+                        script,
+                        BigInt(f.value) as Satoshi,
+                        f.type,
+                    );
                     assert.strictEqual(Buffer.from(hash).toString('hex'), f.hash);
                 },
             );
@@ -303,7 +314,9 @@ describe('Transaction', () => {
     describe('taprootSigning', () => {
         fixtures.taprootSigning.forEach((f) => {
             const tx = Transaction.fromHex(f.txHex);
-            const prevOutScripts = f.utxos.map(({ scriptHex }) => Buffer.from(scriptHex, 'hex')) as unknown as Script[];
+            const prevOutScripts = f.utxos.map(({ scriptHex }) =>
+                Buffer.from(scriptHex, 'hex'),
+            ) as unknown as Script[];
             const values = f.utxos.map(({ value }) => BigInt(value)) as Satoshi[];
 
             f.cases.forEach((c) => {

package/test/tsconfig.json

@@ -7,17 +7,9 @@
         "declaration": false,
         "allowSyntheticDefaultImports": true,
         "rootDir": "../",
-        "rootDirs": [
-            "../src",
-            "../types"
-        ],
-        "types": [
-            "node",
-            "mocha"
-        ],
-        "lib": [
-            "ES2021"
-        ],
+        "rootDirs": ["../src", "../types"],
+        "types": ["node"],
+        "lib": ["ES2021"],
         "resolvePackageJsonImports": true,
         "allowJs": false,
         "resolveJsonModule": true,
@@ -34,15 +26,9 @@
         "noUnusedParameters": true,
         "baseUrl": ".",
         "paths": {
-            "../src/*": [
-                "../ts_src/*"
-            ]
+            "../src/*": ["../ts_src/*"]
         }
     },
-    "include": [
-        "./**/*.ts"
-    ],
-    "exclude": [
-        "../ts_src/**/*.ts"
-    ]
+    "include": ["./**/*.ts"],
+    "exclude": ["../ts_src/**/*.ts"]
 }