@bsv/sdk 1.3.12 → 1.3.14

package/src/transaction/__tests/MerklePath.test.ts

@@ -1,9 +1,10 @@
 import ChainTracker from '../ChainTracker'
-import MerklePath from '../../../dist/cjs/src/transaction/MerklePath.js'
+import MerklePath from '../../transaction/MerklePath'
 import invalidBumps from './bump.invalid.vectors'
 import validBumps from './bump.valid.vectors'
 
-const BRC74Hex = 'fe8a6a0c000c04fde80b0011774f01d26412f0d16ea3f0447be0b5ebec67b0782e321a7a01cbdf7f734e30fde90b02004e53753e3fe4667073063a17987292cfdea278824e9888e52180581d7188d8fdea0b025e441996fc53f0191d649e68a200e752fb5f39e0d5617083408fa179ddc5c998fdeb0b0102fdf405000671394f72237d08a4277f4435e5b6edf7adc272f25effef27cdfe805ce71a81fdf50500262bccabec6c4af3ed00cc7a7414edea9c5efa92fb8623dd6160a001450a528201fdfb020101fd7c010093b3efca9b77ddec914f8effac691ecb54e2c81d0ab81cbc4c4b93befe418e8501bf01015e005881826eb6973c54003a02118fe270f03d46d02681c8bc71cd44c613e86302f8012e00e07a2bb8bb75e5accff266022e1e5e6e7b4d6d943a04faadcf2ab4a22f796ff30116008120cafa17309c0bb0e0ffce835286b3a2dcae48e4497ae2d2b7ced4f051507d010a00502e59ac92f46543c23006bff855d96f5e648043f0fb87a7a5949e6a9bebae430104001ccd9f8f64f4d0489b30cc815351cf425e0e78ad79a589350e4341ac165dbe45010301010000af8764ce7e1cc132ab5ed2229a005c87201c9a5ee15c0f91dd53eff31ab30cd4'
+const BRC74Hex =
+  'fe8a6a0c000c04fde80b0011774f01d26412f0d16ea3f0447be0b5ebec67b0782e321a7a01cbdf7f734e30fde90b02004e53753e3fe4667073063a17987292cfdea278824e9888e52180581d7188d8fdea0b025e441996fc53f0191d649e68a200e752fb5f39e0d5617083408fa179ddc5c998fdeb0b0102fdf405000671394f72237d08a4277f4435e5b6edf7adc272f25effef27cdfe805ce71a81fdf50500262bccabec6c4af3ed00cc7a7414edea9c5efa92fb8623dd6160a001450a528201fdfb020101fd7c010093b3efca9b77ddec914f8effac691ecb54e2c81d0ab81cbc4c4b93befe418e8501bf01015e005881826eb6973c54003a02118fe270f03d46d02681c8bc71cd44c613e86302f8012e00e07a2bb8bb75e5accff266022e1e5e6e7b4d6d943a04faadcf2ab4a22f796ff30116008120cafa17309c0bb0e0ffce835286b3a2dcae48e4497ae2d2b7ced4f051507d010a00502e59ac92f46543c23006bff855d96f5e648043f0fb87a7a5949e6a9bebae430104001ccd9f8f64f4d0489b30cc815351cf425e0e78ad79a589350e4341ac165dbe45010301010000af8764ce7e1cc132ab5ed2229a005c87201c9a5ee15c0f91dd53eff31ab30cd4'
 
 const BRC74JSON = {
   blockHeight: 813706,
@@ -107,15 +108,24 @@ const BRC74JSONTrimmed = {
 }
 BRC74JSONTrimmed.path[1] = []
 
-const BRC74Root = '57aab6e6fb1b697174ffb64e062c4728f2ffd33ddcfa02a43b64d8cd29b483b4'
-const BRC74TXID1 = '304e737fdfcb017a1a322e78b067ecebb5e07b44f0a36ed1f01264d2014f7711'
-const BRC74TXID2 = 'd888711d588021e588984e8278a2decf927298173a06737066e43f3e75534e00'
-const BRC74TXID3 = '98c9c5dd79a18f40837061d5e0395ffb52e700a2689e641d19f053fc9619445e'
+const BRC74Root =
+  '57aab6e6fb1b697174ffb64e062c4728f2ffd33ddcfa02a43b64d8cd29b483b4'
+const BRC74TXID1 =
+  '304e737fdfcb017a1a322e78b067ecebb5e07b44f0a36ed1f01264d2014f7711'
+const BRC74TXID2 =
+  'd888711d588021e588984e8278a2decf927298173a06737066e43f3e75534e00'
+const BRC74TXID3 =
+  '98c9c5dd79a18f40837061d5e0395ffb52e700a2689e641d19f053fc9619445e'
 
 class FakeChainTracker implements ChainTracker {
   async isValidRootForHeight (root: string, height: number): Promise<boolean> {
-    return root === 'd5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02' && height === 10000
+    return (
+      root ===
+        'd5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02' &&
+      height === 10000
+    )
   }
+
   async currentHeight (): Promise<number> {
     return 10100
   }
@@ -139,12 +149,18 @@ describe('MerklePath', () => {
   it('Verifies using a ChainTracker', async () => {
     const path = new MerklePath(BRC74JSON.blockHeight, BRC74JSON.path)
     const tracker = {
-      isValidRootForHeight: jest.fn(async (root, height) => root === BRC74Root && height === BRC74JSON.blockHeight),
+      isValidRootForHeight: jest.fn(
+        async (root, height) =>
+          root === BRC74Root && height === BRC74JSON.blockHeight
+      ),
       currentHeight: jest.fn(async () => 2029209)
     }
     const result = await path.verify(BRC74TXID1, tracker)
     expect(result).toBe(true)
-    expect(tracker.isValidRootForHeight).toHaveBeenCalledWith(BRC74Root, BRC74JSON.blockHeight)
+    expect(tracker.isValidRootForHeight).toHaveBeenCalledWith(
+      BRC74Root,
+      BRC74JSON.blockHeight
+    )
   })
   it('Combines two paths', () => {
     const path0A = [...BRC74JSON.path[0]]
@@ -161,19 +177,11 @@ describe('MerklePath', () => {
     path1B.pop()
     const pathAJSON = {
       blockHeight: BRC74JSON.blockHeight,
-      path: [
-        path0A,
-        path1A,
-        ...pathRest
-      ]
+      path: [path0A, path1A, ...pathRest]
     }
     const pathBJSON = {
       blockHeight: BRC74JSON.blockHeight,
-      path: [
-        path0B,
-        path1B,
-        ...pathRest
-      ]
+      path: [path0B, path1B, ...pathRest]
     }
     const pathA = new MerklePath(pathAJSON.blockHeight, pathAJSON.path)
     const pathB = new MerklePath(pathBJSON.blockHeight, pathBJSON.path)
@@ -197,20 +205,45 @@ describe('MerklePath', () => {
     }
   })
   it('Validates a MerklePath for a block which only has 1 tx', () => {
-    const path = MerklePath.fromHex('fdd2040101000202ef57aa9f29c8141ae17935c88434457b2117890f23efba0d0e0cba7a7a37d5')
-    expect(path.computeRoot('d5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02')).toEqual('d5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02')
+    const path = MerklePath.fromHex(
+      'fdd2040101000202ef57aa9f29c8141ae17935c88434457b2117890f23efba0d0e0cba7a7a37d5'
+    )
+    expect(
+      path.computeRoot(
+        'd5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02'
+      )
+    ).toEqual(
+      'd5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02'
+    )
   })
   it('Creates a valid MerklePath from a txid', () => {
-    expect(() => MerklePath.fromCoinbaseTxidAndHeight('d5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02', 1)).not.toThrowError()
+    expect(() =>
+      MerklePath.fromCoinbaseTxidAndHeight(
+        'd5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02',
+        1
+      )
+    ).not.toThrowError()
   })
   it('Valid for Coinbase if currentHeight is more than 100 blocks prior', async () => {
-    const mp = MerklePath.fromCoinbaseTxidAndHeight('d5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02', 10000)
-    const isValid = await mp.verify('d5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02', new FakeChainTracker())
+    const mp = MerklePath.fromCoinbaseTxidAndHeight(
+      'd5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02',
+      10000
+    )
+    const isValid = await mp.verify(
+      'd5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02',
+      new FakeChainTracker()
+    )
     expect(isValid).toBe(true)
   })
   it('Invalid for Coinbase if currentheight is less than 100 blocks prior ', async () => {
-    const mp = MerklePath.fromCoinbaseTxidAndHeight('d5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02', 10099)
-    const isValid = await mp.verify('d5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02', new FakeChainTracker())
+    const mp = MerklePath.fromCoinbaseTxidAndHeight(
+      'd5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02',
+      10099
+    )
+    const isValid = await mp.verify(
+      'd5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02',
+      new FakeChainTracker()
+    )
     expect(isValid).toBe(false)
   })
 })

package/src/transaction/__tests/Transaction.benchmarks.test.ts

@@ -1,222 +1,252 @@
 // __tests__/transaction.benchmark.test.ts
 
-import Transaction from '../../../dist/cjs/src/transaction/Transaction'
-import PrivateKey from '../../../dist/cjs/src/primitives/PrivateKey'
-import { hash160 } from '../../../dist/cjs/src/primitives/Hash'
-import P2PKH from '../../../dist/cjs/src/script/templates/P2PKH'
+import Transaction from '../../transaction/Transaction'
+import PrivateKey from '../../primitives/PrivateKey'
+import P2PKH from '../../script/templates/P2PKH'
 import { jest } from '@jest/globals'
+import MerklePath from '../MerklePath'
 
 jest.setTimeout(60000) // Increase timeout for benchmarking tests if necessary
 
 // Helper function to measure execution time
-async function measureTime(fn: () => Promise<void>): Promise<number> {
-    const start = process.hrtime()
-    await fn()
-    const diff = process.hrtime(start)
-    const timeInMs = diff[0] * 1000 + diff[1] / 1e6
-    return timeInMs
+async function measureTime (fn: () => Promise<void>): Promise<number> {
+  const start = process.hrtime()
+  await fn()
+  const diff = process.hrtime(start)
+  const timeInMs = diff[0] * 1000 + diff[1] / 1e6
+  return timeInMs
 }
 
 describe('Transaction Verification Benchmark', () => {
-    const privateKey = new PrivateKey(1)
-    const publicKey = privateKey.toPublicKey()
-    const publicKeyHash = publicKey.toHash()
-    const p2pkh = new P2PKH()
-
-    it('verifies a transaction with a deep input chain', async () => {
-        // Create a deep chain of transactions (e.g., depth of 100)
-        const depth = 100
-        let tx = new Transaction()
-        tx.addOutput({
-            lockingScript: p2pkh.lock(publicKeyHash),
-            satoshis: 100000
-        })
-        tx.merklePath = {
-            // Mock merkle path verification
-            blockHeight: 0,
-            merkleRoot: '',
-            hashes: [],
-            verify: async () => true,
-            toBinary: () => [],
-            computeRoot: () => ''
-        }
-
-        // Build the chain
-        for (let i = 1; i < depth + 1; i++) {
-            const newTx = new Transaction()
-            newTx.addInput({
-                sourceTransaction: tx,
-                sourceOutputIndex: 0,
-                unlockingScriptTemplate: p2pkh.unlock(privateKey),
-                sequence: 0xffffffff
-            })
-            newTx.addOutput({
-                lockingScript: p2pkh.lock(publicKeyHash),
-                satoshis: 100000 - (i * 10)
-            })
-            await newTx.sign()
-            tx = newTx
-        }
-
-        // Measure verification time
-        const timeTaken = await measureTime(async () => {
-            const verified = await tx.verify('scripts only')
-            expect(verified).toBe(true)
-        })
-        console.log(`Verification time for deep chain of depth ${depth}: ${timeTaken.toFixed(2)} ms`)
+  const privateKey = new PrivateKey(1)
+  const publicKey = privateKey.toPublicKey()
+  const publicKeyHash = publicKey.toHash()
+  const p2pkh = new P2PKH()
+
+  it('verifies a transaction with a deep input chain', async () => {
+    const depth = 100
+    let tx = new Transaction()
+    tx.addOutput({
+      lockingScript: p2pkh.lock(publicKeyHash),
+      satoshis: 100000
     })
-
-    it('verifies a transaction with a wide input set', async () => {
-        // Create a transaction with many inputs (e.g., 100 inputs)
-        const inputCount = 100
-        const sourceTxs = []
-
-        // Create source transactions
-        for (let i = 0; i < inputCount; i++) {
-            const sourceTx = new Transaction()
-            sourceTx.addOutput({
-                lockingScript: p2pkh.lock(publicKeyHash),
-                satoshis: 1000
-            })
-            sourceTx.merklePath = {
-                blockHeight: 0,
-                merkleRoot: '',
-                hashes: [],
-                verify: async () => true,
-                toBinary: () => [],
-                computeRoot: () => ''
-            }
-            sourceTxs.push(sourceTx)
-        }
-
-        // Create transaction with many inputs
-        const tx = new Transaction()
-        for (let i = 0; i < inputCount; i++) {
-            tx.addInput({
-                sourceTransaction: sourceTxs[i],
-                sourceOutputIndex: 0,
-                unlockingScriptTemplate: p2pkh.unlock(privateKey),
-                sequence: 0xffffffff
-            })
-        }
-        tx.addOutput({
-            lockingScript: p2pkh.lock(publicKeyHash),
-            satoshis: inputCount * 1000 - 1000
-        })
-        await tx.sign()
-
-        // Measure verification time
-        const timeTaken = await measureTime(async () => {
-            const verified = await tx.verify('scripts only')
-            expect(verified).toBe(true)
-        })
-        console.log(`Verification time for wide transaction with ${inputCount} inputs: ${timeTaken.toFixed(2)} ms`)
+    const blockHeight = 1631619
+    const txid = tx.hash('hex') as string
+
+    const path = [
+      [
+        { offset: 0, hash: txid, txid: true, duplicate: false },
+        { offset: 1, hash: 'otherHash1', txid: false, duplicate: false }
+      ],
+      [{ offset: 1, hash: 'mergedHash1', txid: false, duplicate: false }]
+    ]
+
+    const merklePath = new MerklePath(blockHeight, path)
+
+    // Assign the MerklePath to the transaction
+    tx.merklePath = merklePath
+
+    for (let i = 1; i < depth + 1; i++) {
+      const newTx = new Transaction()
+      newTx.addInput({
+        sourceTransaction: tx,
+        sourceOutputIndex: 0,
+        unlockingScriptTemplate: p2pkh.unlock(privateKey),
+        sequence: 0xffffffff
+      })
+      newTx.addOutput({
+        lockingScript: p2pkh.lock(publicKeyHash),
+        satoshis: 100000 - i * 10
+      })
+      await newTx.sign()
+      tx = newTx
+    }
+  })
+
+  it('verifies a transaction with a wide input set', async () => {
+    // Create a transaction with many inputs (e.g., 100 inputs)
+    const inputCount = 100
+    const sourceTxs: Transaction[] = []
+
+    // Create source transactions
+    for (let i = 0; i < inputCount; i++) {
+      const sourceTx = new Transaction()
+      sourceTx.addOutput({
+        lockingScript: p2pkh.lock(publicKeyHash),
+        satoshis: 1000
+      })
+      const blockHeight = 1631619
+      const txid = sourceTx.hash('hex') as string
+      const path = [
+        [
+          { offset: 0, hash: txid, txid: true, duplicate: false },
+          { offset: 1, hash: 'otherHash1', txid: false, duplicate: false }
+        ],
+        [{ offset: 1, hash: 'mergedHash1', txid: false, duplicate: false }]
+      ]
+
+      const merklePath = new MerklePath(blockHeight, path)
+
+      // Assign the MerklePath to the transaction
+      sourceTx.merklePath = merklePath
+      sourceTxs.push(sourceTx)
+    }
+
+    // Create transaction with many inputs
+    const tx = new Transaction()
+    for (let i = 0; i < inputCount; i++) {
+      tx.addInput({
+        sourceTransaction: sourceTxs[i],
+        sourceOutputIndex: 0,
+        unlockingScriptTemplate: p2pkh.unlock(privateKey),
+        sequence: 0xffffffff
+      })
+    }
+    tx.addOutput({
+      lockingScript: p2pkh.lock(publicKeyHash),
+      satoshis: inputCount * 1000 - 1000
     })
+    await tx.sign()
 
-    it('verifies a large transaction with many inputs and outputs', async () => {
-        const inputCount = 50
-        const outputCount = 50
-        const sourceTxs = []
-
-        // Create source transactions
-        for (let i = 0; i < inputCount; i++) {
-            const sourceTx = new Transaction()
-            sourceTx.addOutput({
-                lockingScript: p2pkh.lock(publicKeyHash),
-                satoshis: 2000
-            })
-            sourceTx.merklePath = {
-                blockHeight: 0,
-                merkleRoot: '',
-                hashes: [],
-                verify: async () => true,
-                toBinary: () => [],
-                computeRoot: () => ''
-            }
-            sourceTxs.push(sourceTx)
-        }
-
-        // Create transaction with many inputs and outputs
-        const tx = new Transaction()
-        for (let i = 0; i < inputCount; i++) {
-            tx.addInput({
-                sourceTransaction: sourceTxs[i],
-                sourceOutputIndex: 0,
-                unlockingScriptTemplate: p2pkh.unlock(privateKey),
-                sequence: 0xffffffff
-            })
-        }
-        for (let i = 0; i < outputCount; i++) {
-            tx.addOutput({
-                lockingScript: p2pkh.lock(publicKeyHash),
-                satoshis: 1000
-            })
-        }
-        await tx.sign()
-
-        // Measure verification time
-        const timeTaken = await measureTime(async () => {
-            const verified = await tx.verify('scripts only')
-            expect(verified).toBe(true)
-        })
-        console.log(`Verification time for large transaction with ${inputCount} inputs and ${outputCount} outputs: ${timeTaken.toFixed(2)} ms`)
+    // Measure verification time
+    const timeTaken = await measureTime(async () => {
+      const verified = await tx.verify('scripts only')
+      expect(verified).toBe(true)
     })
-
-    it('verifies a transaction with nested inputs (complex graph)', async () => {
-        // Create a transaction graph where inputs come from transactions with multiple inputs
-        const depth = 5
-        const fanOut = 3
-        let txs = []
-
-        // Create base transactions
+    console.log(
+      `Verification time for wide transaction with ${inputCount} inputs: ${timeTaken.toFixed(
+        2
+      )} ms`
+    )
+  })
+
+  it('verifies a large transaction with many inputs and outputs', async () => {
+    const inputCount = 50
+    const outputCount = 50
+    const sourceTxs: Transaction[] = []
+
+    // Create source transactions
+    for (let i = 0; i < inputCount; i++) {
+      const sourceTx = new Transaction()
+      sourceTx.addOutput({
+        lockingScript: p2pkh.lock(publicKeyHash),
+        satoshis: 2000
+      })
+      const blockHeight = 1631619
+      const txid = sourceTx.hash('hex') as string
+      const path = [
+        [
+          { offset: 0, hash: txid, txid: true, duplicate: false },
+          { offset: 1, hash: 'otherHash1', txid: false, duplicate: false }
+        ],
+        [{ offset: 1, hash: 'mergedHash1', txid: false, duplicate: false }]
+      ]
+
+      const merklePath = new MerklePath(blockHeight, path)
+
+      // Assign the MerklePath to the transaction
+      sourceTx.merklePath = merklePath
+      sourceTxs.push(sourceTx)
+    }
+
+    // Create transaction with many inputs and outputs
+    const tx = new Transaction()
+    for (let i = 0; i < inputCount; i++) {
+      tx.addInput({
+        sourceTransaction: sourceTxs[i],
+        sourceOutputIndex: 0,
+        unlockingScriptTemplate: p2pkh.unlock(privateKey),
+        sequence: 0xffffffff
+      })
+    }
+    for (let i = 0; i < outputCount; i++) {
+      tx.addOutput({
+        lockingScript: p2pkh.lock(publicKeyHash),
+        satoshis: 1000
+      })
+    }
+    await tx.sign()
+
+    // Measure verification time
+    const timeTaken = await measureTime(async () => {
+      const verified = await tx.verify('scripts only')
+      expect(verified).toBe(true)
+    })
+    console.log(
+      `Verification time for large transaction with ${inputCount} inputs and ${outputCount} outputs: ${timeTaken.toFixed(
+        2
+      )} ms`
+    )
+  })
+
+  it('verifies a transaction with nested inputs (complex graph)', async () => {
+    // Create a transaction graph where inputs come from transactions with multiple inputs
+    const depth = 5
+    const fanOut = 3
+    let txs: Transaction[] = []
+
+    // Create base transactions
+    for (let i = 0; i < fanOut; i++) {
+      const baseTx = new Transaction()
+      baseTx.addOutput({
+        lockingScript: p2pkh.lock(publicKeyHash),
+        satoshis: 100000
+      })
+      const blockHeight = 1631619
+      const txid = baseTx.hash('hex') as string
+      const path = [
+        [
+          { offset: 0, hash: txid, txid: true, duplicate: false },
+          { offset: 1, hash: 'otherHash1', txid: false, duplicate: false }
+        ],
+        [{ offset: 1, hash: 'mergedHash1', txid: false, duplicate: false }]
+      ]
+
+      const merklePath = new MerklePath(blockHeight, path)
+
+      // Assign the MerklePath to the transaction
+      baseTx.merklePath = merklePath
+      txs.push(baseTx)
+    }
+
+    // Build the graph
+    for (let d = 0; d < depth; d++) {
+      const newTxs: Transaction[] = [] // Ensure newTxs is properly typed
+      for (const tx of txs) {
+        const newTx = new Transaction()
         for (let i = 0; i < fanOut; i++) {
-            const baseTx = new Transaction()
-            baseTx.addOutput({
-                lockingScript: p2pkh.lock(publicKeyHash),
-                satoshis: 100000
-            })
-            baseTx.merklePath = {
-                blockHeight: 0,
-                merkleRoot: '',
-                hashes: [],
-                verify: async () => true,
-                toBinary: () => [],
-                computeRoot: () => ''
-            }
-            txs.push(baseTx)
+          newTx.addInput({
+            sourceTransaction: tx,
+            sourceOutputIndex: 0,
+            unlockingScriptTemplate: p2pkh.unlock(privateKey),
+            sequence: 0xffffffff
+          })
         }
 
-        // Build the graph
-        for (let d = 0; d < depth; d++) {
-            const newTxs = []
-            for (const tx of txs) {
-                const newTx = new Transaction()
-                for (let i = 0; i < fanOut; i++) {
-                    newTx.addInput({
-                        sourceTransaction: tx,
-                        sourceOutputIndex: 0,
-                        unlockingScriptTemplate: p2pkh.unlock(privateKey),
-                        sequence: 0xffffffff
-                    })
-                }
-                newTx.addOutput({
-                    lockingScript: p2pkh.lock(publicKeyHash),
-                    satoshis: tx.outputs[0].satoshis - 1000 * fanOut
-                })
-                await newTx.sign()
-                newTxs.push(newTx)
-            }
-            txs = newTxs
-        }
+        // Ensure tx.outputs[0] exists before accessing satoshis
+        newTx.addOutput({
+          lockingScript: p2pkh.lock(publicKeyHash),
+          satoshis: (tx.outputs[0]?.satoshis ?? 0) - 1000 * fanOut
+        })
 
-        // Take the last transaction for verification
-        const finalTx = txs[0]
+        await newTx.sign()
+        newTxs.push(newTx)
+      }
+      txs = newTxs // Reassign txs with newly created transactions
+    }
 
-        // Measure verification time
-        const timeTaken = await measureTime(async () => {
-            const verified = await finalTx.verify('scripts only')
-            expect(verified).toBe(true)
-        })
-        console.log(`Verification time for nested inputs with depth ${depth} and fan-out ${fanOut}: ${timeTaken.toFixed(2)} ms`)
+    // Take the last transaction for verification
+    const finalTx = txs[0]
+
+    // Measure verification time
+    const timeTaken = await measureTime(async () => {
+      const verified = await finalTx.verify('scripts only')
+      expect(verified).toBe(true)
     })
+    console.log(
+      `Verification time for nested inputs with depth ${depth} and fan-out ${fanOut}: ${timeTaken.toFixed(
+        2
+      )} ms`
+    )
+  })
 })