@bsv/sdk 1.4.20 → 1.4.22

package/src/transaction/Transaction.ts

@@ -761,6 +761,8 @@ export default class Transaction {
    * Verifies the legitimacy of the Bitcoin transaction according to the rules of SPV by ensuring all the input transactions link back to valid block headers, the chain of spends for all inputs are valid, and the sum of inputs is not less than the sum of outputs.
    *
    * @param chainTracker - An instance of ChainTracker, a Bitcoin block header tracker. If the value is set to 'scripts only', headers will not be verified. If not provided then the default chain tracker will be used.
+   * @param feeModel - An instance of FeeModel, a fee model to use for fee calculation. If not provided then the default fee model will be used.
+   * @param memoryLimit - The maximum memory in bytes usage allowed for script evaluation. If not provided then the default memory limit will be used.
    *
    * @returns Whether the transaction is valid according to the rules of SPV.
    *
@@ -768,7 +770,8 @@ export default class Transaction {
    */
   async verify (
     chainTracker: ChainTracker | 'scripts only' = defaultChainTracker(),
-    feeModel?: FeeModel
+    feeModel?: FeeModel,
+    memoryLimit?: number
   ): Promise<boolean> {
     const verifiedTxids = new Set<string>()
     const txQueue: Transaction[] = [this]
@@ -856,7 +859,8 @@ export default class Transaction {
           inputSequence: input.sequence ?? 0,
           inputIndex: i,
           outputs: tx.outputs,
-          lockTime: tx.lockTime
+          lockTime: tx.lockTime,
+          memoryLimit
         })
         const spendValid = spend.validate()
 

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

@@ -13,6 +13,7 @@ import P2PKH from '../../script/templates/P2PKH'
 import fromUtxo from '../../compat/Utxo'
 import MerklePath from '../../transaction/MerklePath'
 import { BEEF_V1 } from '../../transaction/Beef'
+import SatoshisPerKilobyte from '../../transaction/fee-models/SatoshisPerKilobyte'
 
 import sighashVectors from '../../primitives/__tests/sighash.vectors'
 import invalidTransactions from './tx.invalid.vectors'
@@ -1138,6 +1139,7 @@ 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 tx = new Transaction()
         tx.addInput({
@@ -1146,11 +1148,16 @@ describe('Transaction', () => {
           unlockingScriptTemplate: new P2PKH().unlock(privateKey)
         })
         tx.addP2PKHOutput(privateKey.toAddress(), 10000)
-        expect(tx.outputs.length).toEqual(1)
+        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()
         ).toBeTruthy()
+        expect(
+          tx.outputs[0].lockingScript.toHex() === tx.outputs[1].lockingScript.toHex()
+        ).toBeTruthy()        
       })
     })
   })
@@ -1293,4 +1300,121 @@ describe('Transaction', () => {
       })
     })
   })
+
+  describe('preventResourceExhaustion', () => {
+    it('should run script evaluation but error out as soon as the memory usage exceeds the limit', async () => {
+      const sourceTransaction = new Transaction()
+      sourceTransaction.addInput({
+        sourceTXID: '00'.repeat(32),
+        sourceOutputIndex: 0,
+        unlockingScript: Script.fromASM('OP_TRUE'),
+      })
+      sourceTransaction.addOutput({
+        satoshis: 2,
+        lockingScript: Script.fromASM('OP_2 OP_MUL ' + 'OP_DUP OP_MUL '.repeat(16) + 'OP_DROP'),
+      })
+      await sourceTransaction.sign()
+
+      sourceTransaction.merklePath = new MerklePath(1000, [
+        [
+          { offset: 0, hash: sourceTransaction.id('hex'), txid: true },
+          { offset: 1, duplicate: true }
+        ]
+      ])
+
+      const tx = new Transaction()
+      tx.addInput({
+        sourceTransaction,
+        sourceOutputIndex: 0,
+        unlockingScript: Script.fromASM('OP_TRUE ' + 'deadbeef'.repeat(2))
+      })
+      tx.addOutput({
+        satoshis: 1,
+        lockingScript: Script.fromASM('OP_NOP'),
+      })
+      await tx.fee()
+      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')
+    })
+  })
+
+  describe('preventResourceExhaustionP2PKH', () => {
+    it('should run script evaluation with only 144 bytes of memory allocation and still be valid for a simple P2PKH', async () => {
+      const key = PrivateKey.fromRandom()
+      const sourceTransaction = new Transaction()
+      sourceTransaction.addInput({
+        sourceTXID: '00'.repeat(32),
+        sourceOutputIndex: 0,
+        unlockingScript: Script.fromASM('OP_TRUE'),
+      })
+      sourceTransaction.addOutput({
+        satoshis: 2,
+        lockingScript: new P2PKH().lock(key.toAddress()),
+      })
+      await sourceTransaction.sign()
+
+      sourceTransaction.merklePath = new MerklePath(1000, [
+        [
+          { offset: 0, hash: sourceTransaction.id('hex'), txid: true },
+          { offset: 1, duplicate: true }
+        ]
+      ])
+
+      const tx = new Transaction()
+      tx.addInput({
+        sourceTransaction,
+        sourceOutputIndex: 0,
+        unlockingScriptTemplate: new P2PKH().unlock(key, 'none', true)
+      })
+      tx.addOutput({
+        satoshis: 1,
+        lockingScript: Script.fromASM('OP_NOP'),
+      })
+      await tx.fee()
+      await tx.sign()
+
+      // P2PKH takes less than 150 bytes apparently
+      await expect(tx.verify('scripts only', new SatoshisPerKilobyte(1), 150)).resolves.toBe(true)
+    })
+  })
+
+  describe('preventResourceExhaustionSmall', () => {
+    it('should run script evaluation and pass so long as we stay within the limit', async () => {
+      const sourceTransaction = new Transaction()
+      sourceTransaction.addInput({
+        sourceTXID: '00'.repeat(32),
+        sourceOutputIndex: 0,
+        unlockingScript: Script.fromASM('OP_TRUE'),
+      })
+      sourceTransaction.addOutput({
+        satoshis: 2,
+        lockingScript: Script.fromASM('OP_2 OP_MUL OP_DUP OP_MUL OP_DUP OP_MUL OP_DROP'),
+      })
+      await sourceTransaction.sign()
+
+      sourceTransaction.merklePath = new MerklePath(1000, [
+        [
+          { offset: 0, hash: sourceTransaction.id('hex'), txid: true },
+          { offset: 1, duplicate: true }
+        ]
+      ])
+
+      const tx = new Transaction()
+      tx.addInput({
+        sourceTransaction,
+        sourceOutputIndex: 0,
+        unlockingScript: Script.fromASM('OP_TRUE ' + 'deadbeef'.repeat(2))
+      })
+      tx.addOutput({
+        satoshis: 1,
+        lockingScript: Script.fromASM('OP_NOP'),
+      })
+      await tx.fee()
+      await tx.sign()
+
+      await expect(tx.verify('scripts only', new SatoshisPerKilobyte(1), 35)).resolves.toBe(true)
+    })
+  })
 })