@bsv/sdk 1.5.3 → 1.6.0

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

@@ -26,6 +26,9 @@ const BRC62Hex =
 const MerkleRootFromBEEF =
   'bb6f640cc4ee56bf38eb5a1969ac0c16caa2d3d202b22bf3735d10eec0ca6e00'
 
+const testPrivateKey = new PrivateKey(11)
+const testP2PKHScript = new P2PKH().lock(testPrivateKey.toPublicKey().toHash())
+
 describe('Transaction', () => {
   const txhex =
     '000000000100000000000000000000000000000000000000000000000000000000000000000000000001ae0000000001050000000000000001ae00000000'
@@ -713,19 +716,18 @@ describe('Transaction', () => {
           value: 10000
         }
       ]
-      const priv = PrivateKey.fromRandom()
       const tx = new Transaction()
       utxos.forEach(utxo => {
         const u = {
           txid: utxo.tx_hash,
           vout: utxo.tx_pos,
-          script: new P2PKH().lock(priv.toPublicKey().toHash()).toHex(),
+          script: testP2PKHScript.toHex(),
           satoshis: utxo.value
         }
-        tx.addInput(fromUtxo(u, new P2PKH().unlock(priv)))
+        tx.addInput(fromUtxo(u, new P2PKH().unlock(testPrivateKey)))
       })
       tx.addOutput({
-        lockingScript: new P2PKH().lock(priv.toAddress()),
+        lockingScript: testP2PKHScript,
         change: true
       })
       await tx.fee({ computeFee: async () => 10 })
@@ -1138,26 +1140,24 @@ describe('Transaction', () => {
 
     describe('addP2PKHOutput', () => {
       it('should create an output on the current transaction using an address hash or string', async () => {
-        const privateKey = PrivateKey.fromRandom()
-        const pubKeyHash = privateKey.toPublicKey().toHash()
-        const lockingScript = new P2PKH().lock(privateKey.toAddress())
+        const pubKeyHash = testPrivateKey.toPublicKey().toHash()
         const tx = new Transaction()
         tx.addInput({
           sourceTXID: '00'.repeat(32),
           sourceOutputIndex: 0,
-          unlockingScriptTemplate: new P2PKH().unlock(privateKey)
+          unlockingScriptTemplate: new P2PKH().unlock(testPrivateKey)
         })
-        tx.addP2PKHOutput(privateKey.toAddress(), 10000)
+        tx.addP2PKHOutput(testPrivateKey.toAddress(), 10000)
         tx.addP2PKHOutput(pubKeyHash, 10000)
         expect(tx.outputs.length).toEqual(2)
         expect(tx.outputs[0].satoshis).toEqual(10000)
         expect(tx.outputs[1].satoshis).toEqual(10000)
         expect(
-          tx.outputs[0].lockingScript.toHex() === lockingScript.toHex()
+          tx.outputs[0].lockingScript.toHex() === testP2PKHScript.toHex()
         ).toBeTruthy()
         expect(
           tx.outputs[0].lockingScript.toHex() === tx.outputs[1].lockingScript.toHex()
-        ).toBeTruthy()        
+        ).toBeTruthy()
       })
     })
   })
@@ -1290,13 +1290,11 @@ describe('Transaction', () => {
 
   describe('addP2PKHOutput', () => {
     it('should create an output on the current transaction using an address hash or string', async () => {
-      const privateKey = PrivateKey.fromRandom()
-      const lockingScript = new P2PKH().lock(privateKey.toAddress())
       const tx = new Transaction()
       tx.addInput({
         sourceTXID: '00'.repeat(32),
         sourceOutputIndex: 0,
-        unlockingScriptTemplate: new P2PKH().unlock(privateKey),
+        unlockingScriptTemplate: new P2PKH().unlock(testPrivateKey),
       })
     })
   })
@@ -1311,7 +1309,7 @@ describe('Transaction', () => {
       })
       sourceTransaction.addOutput({
         satoshis: 2,
-        lockingScript: Script.fromASM('OP_2 OP_MUL ' + 'OP_DUP OP_MUL '.repeat(16) + 'OP_DROP'),
+        lockingScript: Script.fromASM('OP_2 OP_MUL ' + 'OP_DUP OP_MUL '.repeat(22) + 'OP_DROP'),
       })
       await sourceTransaction.sign()
 
@@ -1336,7 +1334,7 @@ describe('Transaction', () => {
       await tx.sign()
 
       // default should be 100KB
-      await expect(tx.verify('scripts only', new SatoshisPerKilobyte(1))).rejects.toThrow('Stack memory usage has exceeded 100000 bytes')
+      await expect(tx.verify('scripts only', new SatoshisPerKilobyte(1))).rejects.toThrow('Stack memory usage has exceeded 32000000 bytes')
     })
   })
 

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

@@ -1,237 +0,0 @@
-// __tests__/transaction.benchmark.test.ts
-
-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
-}
-
-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 () => {
-    const depth = 100
-    let tx = new Transaction()
-    tx.addOutput({
-      lockingScript: p2pkh.lock(publicKeyHash),
-      satoshis: 100000
-    })
-    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()
-
-    // Measure verification time
-    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: 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)
-    })
-  })
-
-  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++) {
-          newTx.addInput({
-            sourceTransaction: tx,
-            sourceOutputIndex: 0,
-            unlockingScriptTemplate: p2pkh.unlock(privateKey),
-            sequence: 0xffffffff
-          })
-        }
-
-        // Ensure tx.outputs[0] exists before accessing satoshis
-        newTx.addOutput({
-          lockingScript: p2pkh.lock(publicKeyHash),
-          satoshis: (tx.outputs[0]?.satoshis ?? 0) - 1000 * fanOut
-        })
-
-        await newTx.sign()
-        newTxs.push(newTx)
-      }
-      txs = newTxs // Reassign txs with newly created transactions
-    }
-
-    // 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)
-    })
-  })
-})