@bsv/sdk 1.3.12 → 1.3.13

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

@@ -1,222 +1,255 @@
 // __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 { hash160 } from '../../primitives/Hash'
+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
+  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
+    }
+
+    const timeTaken = await measureTime(async () => {
+      const verified = await tx.verify('scripts only')
+      expect(verified).toBe(true)
     })
-
-    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`)
+  })
+
+  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
+      })
+      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 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
+    // 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`
+    )
+  })
+
+  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
+      })
+      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 = []
+
+    // 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 = []
+      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)
-        }
-
-        // 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
+          newTx.addInput({
+            sourceTransaction: tx,
+            sourceOutputIndex: 0,
+            unlockingScriptTemplate: p2pkh.unlock(privateKey),
+            sequence: 0xffffffff
+          })
         }
-
-        // 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)
+        newTx.addOutput({
+          lockingScript: p2pkh.lock(publicKeyHash),
+          satoshis: tx.outputs[0].satoshis - 1000 * fanOut
         })
-        console.log(`Verification time for nested inputs with depth ${depth} and fan-out ${fanOut}: ${timeTaken.toFixed(2)} ms`)
+        await newTx.sign()
+        newTxs.push(newTx)
+      }
+      txs = newTxs
+    }
+
+    // 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`
+    )
+  })
 })