@bsv/sdk 1.4.20 → 1.4.22

package/docs/transaction.md

@@ -1974,7 +1974,7 @@ Argument Details
 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.
 
 ```ts
-async verify(chainTracker: ChainTracker | "scripts only" = defaultChainTracker(), feeModel?: FeeModel): Promise<boolean> 
+async verify(chainTracker: ChainTracker | "scripts only" = defaultChainTracker(), feeModel?: FeeModel, memoryLimit?: number): Promise<boolean> 
 ```
 See also: [ChainTracker](./transaction.md#interface-chaintracker), [FeeModel](./transaction.md#interface-feemodel), [defaultChainTracker](./transaction.md#function-defaultchaintracker)
 
@@ -1986,6 +1986,10 @@ Argument Details
 
 + **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.
++ **feeModel**
+  + An instance of FeeModel, a fee model to use for fee calculation. If not provided then the default fee model will be used.
++ **memoryLimit**
+  + The maximum memory in bytes usage allowed for script evaluation. If not provided then the default memory limit will be used.
 
 Example
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.4.20",
+  "version": "1.4.22",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",

package/src/script/Spend.ts

@@ -38,6 +38,7 @@ const requireCleanStack = true
  * @property {number} inputIndex - The index of this input in the current transaction.
  * @property {UnlockingScript} unlockingScript - The unlocking script that unlocks the UTXO for spending.
  * @property {number} inputSequence - The sequence number of this input.
+ * @property {number} lockTime - The lock time of the transaction.
  */
 export default class Spend {
   sourceTXID: string
@@ -57,6 +58,9 @@ export default class Spend {
   stack: number[][]
   altStack: number[][]
   ifStack: boolean[]
+  memoryLimit: number
+  stackMem: number
+  altStackMem: number
 
   /**
    * @constructor
@@ -87,6 +91,7 @@ export default class Spend {
    *   inputIndex: 0, // inputIndex
    *   unlockingScript: UnlockingScript.fromASM("3045... 02ab..."),
    *   inputSequence: 0xffffffff // inputSequence
+   *   memoryLimit: 100000 // memoryLimit
    * });
    */
   constructor (params: {
@@ -101,6 +106,7 @@ export default class Spend {
     inputSequence: number
     inputIndex: number
     lockTime: number
+    memoryLimit?: number
   }) {
     this.sourceTXID = params.sourceTXID
     this.sourceOutputIndex = params.sourceOutputIndex
@@ -113,6 +119,9 @@ export default class Spend {
     this.unlockingScript = params.unlockingScript
     this.inputSequence = params.inputSequence
     this.lockTime = params.lockTime
+    this.memoryLimit = params.memoryLimit ?? 100000 // 100 MB is going to be processed by most miners by policy, but the default should protect apps against memory attacks.
+    this.stackMem = 0
+    this.altStackMem = 0
     this.reset()
   }
 
@@ -123,9 +132,27 @@ export default class Spend {
     this.stack = []
     this.altStack = []
     this.ifStack = []
+    this.stackMem = 0
+    this.altStackMem = 0
   }
 
-  step (): void {
+  step (): boolean {
+    let poppedValue: number[] | undefined
+    // If the stack (or alt stack) is over the memory limit, evaluation has failed.
+    if (this.stackMem > this.memoryLimit) {
+      this.scriptEvaluationError('Stack memory usage has exceeded ' + String(this.memoryLimit) + ' bytes')
+      return false
+    }
+    if (this.altStackMem > this.memoryLimit) {
+      this.scriptEvaluationError('Alt stack memory usage has exceeded ' + String(this.memoryLimit) + ' bytes')
+      return false
+    }
+
+    // Clear popped values after use to free memory
+    const clearPoppedValue = (): void => {
+      poppedValue = undefined
+    }
+
     // If the context is UnlockingScript and we have reached the end,
     // set the context to LockingScript and zero the program counter
     if (
@@ -264,6 +291,10 @@ export default class Spend {
         //  Non-canonical signature: R value type mismatch
         return false
       }
+      if (buf[4 - 1] !== nLEnR) {
+        //  Non-canonical signature: R length mismatch
+        return false
+      }
       if (nLEnR === 0) {
         //  Non-canonical signature: R length is zero
         return false
@@ -282,6 +313,10 @@ export default class Spend {
         //  Non-canonical signature: S value type mismatch
         return false
       }
+      if (buf[6 + nLEnR - 1] !== nLEnS) {
+        //  Non-canonical signature: S length mismatch
+        return false
+      }
       if (nLEnS === 0) {
         //  Non-canonical signature: S length is zero
         return false
@@ -305,14 +340,20 @@ export default class Spend {
       }
 
       if (!isChecksigFormat(buf)) {
-        this.scriptEvaluationError('The signature format is invalid.')
+        this.scriptEvaluationError(
+          'The signature format is invalid.'
+        )
       }
       const sig = TransactionSignature.fromChecksigFormat(buf)
       if (requireLowSSignatures && !sig.hasLowS()) {
-        this.scriptEvaluationError('The signature must have a low S value.')
+        this.scriptEvaluationError(
+          'The signature must have a low S value.'
+        )
       }
       if ((sig.scope & TransactionSignature.SIGHASH_FORKID) === 0) {
-        this.scriptEvaluationError('The signature must use SIGHASH_FORKID.')
+        this.scriptEvaluationError(
+          'The signature must use SIGHASH_FORKID.'
+        )
         return false
       }
 
@@ -338,7 +379,9 @@ export default class Spend {
           )
         }
       } else {
-        this.scriptEvaluationError('The public key is in an unknown format.')
+        this.scriptEvaluationError(
+          'The public key is in an unknown format.'
+        )
       }
       return true
     }
@@ -428,8 +471,10 @@ export default class Spend {
 
       if (!Array.isArray(operation.data)) {
         this.stack.push([])
+        this.stackMem += 0
       } else {
         this.stack.push(operation.data)
+        this.stackMem += operation.data.length
       }
     } else if (
       isScriptExecuting ||
@@ -456,6 +501,7 @@ export default class Spend {
           n = currentOpcode - (OP.OP_1 - 1)
           buf = new BigNumber(n).toScriptNum()
           this.stack.push(buf)
+          this.stackMem += buf.length
           break
 
         case OP.OP_NOP:
@@ -550,7 +596,11 @@ export default class Spend {
             if (currentOpcode === OP.OP_NOTIF) {
               fValue = !fValue
             }
-            this.stack.pop()
+            poppedValue = this.stack.pop()
+            if (poppedValue != null) {
+              this.stackMem -= poppedValue.length
+            }
+            clearPoppedValue()
           }
           this.ifStack.push(fValue)
           break
@@ -578,9 +628,12 @@ export default class Spend {
           }
           buf = this.stacktop(-1)
           fValue = this.castToBool(buf)
-          if (fValue) {
-            this.stack.pop()
-          } else {
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
+          if (!fValue) {
             this.scriptEvaluationError(
               'OP_VERIFY requires the top stack value to be truthy.'
             )
@@ -601,7 +654,13 @@ export default class Spend {
             this.scriptEvaluationError(
               'OP_TOALTSTACK requires at oeast one item to be on the stack.')
           }
-          this.altStack.push(this.stack.pop() ?? [])
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.altStack.push(poppedValue)
+            this.altStackMem += poppedValue.length
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
           break
 
         case OP.OP_FROMALTSTACK:
@@ -610,7 +669,13 @@ export default class Spend {
               'OP_FROMALTSTACK requires at least one item to be on the stack.'
             )
           }
-          this.stack.push(this.altStack.pop() ?? [])
+          poppedValue = this.altStack.pop()
+          if (poppedValue != null) {
+            this.stack.push(poppedValue)
+            this.stackMem += poppedValue.length
+            this.altStackMem -= poppedValue.length
+          }
+          clearPoppedValue()
           break
 
         case OP.OP_2DROP:
@@ -619,8 +684,16 @@ export default class Spend {
               'OP_2DROP requires at least two items to be on the stack.'
             )
           }
-          this.stack.pop()
-          this.stack.pop()
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
           break
 
         case OP.OP_2DUP:
@@ -632,7 +705,9 @@ export default class Spend {
           buf1 = this.stacktop(-2)
           buf2 = this.stacktop(-1)
           this.stack.push([...buf1])
+          this.stackMem += buf1.length
           this.stack.push([...buf2])
+          this.stackMem += buf2.length
           break
 
         case OP.OP_3DUP:
@@ -645,8 +720,11 @@ export default class Spend {
           buf2 = this.stacktop(-2)
           buf3 = this.stacktop(-1)
           this.stack.push([...buf1])
+          this.stackMem += buf1.length
           this.stack.push([...buf2])
+          this.stackMem += buf2.length
           this.stack.push([...buf3])
+          this.stackMem += buf3.length
           break
 
         case OP.OP_2OVER:
@@ -658,7 +736,9 @@ export default class Spend {
           buf1 = this.stacktop(-4)
           buf2 = this.stacktop(-3)
           this.stack.push([...buf1])
+          this.stackMem += buf1.length
           this.stack.push([...buf2])
+          this.stackMem += buf2.length
           break
 
         case OP.OP_2ROT:
@@ -669,7 +749,9 @@ export default class Spend {
           }
           spliced = this.stack.splice(this.stack.length - 6, 2)
           this.stack.push(spliced[0])
+          this.stackMem += spliced[0].length
           this.stack.push(spliced[1])
+          this.stackMem += spliced[1].length
           break
 
         case OP.OP_2SWAP:
@@ -680,7 +762,9 @@ export default class Spend {
           }
           spliced = this.stack.splice(this.stack.length - 4, 2)
           this.stack.push(spliced[0])
+          this.stackMem += spliced[0].length
           this.stack.push(spliced[1])
+          this.stackMem += spliced[1].length
           break
 
         case OP.OP_IFDUP:
@@ -693,12 +777,14 @@ export default class Spend {
           fValue = this.castToBool(buf)
           if (fValue) {
             this.stack.push([...buf])
+            this.stackMem += buf.length
           }
           break
 
         case OP.OP_DEPTH:
           buf = new BigNumber(this.stack.length).toScriptNum()
           this.stack.push(buf)
+          this.stackMem += buf.length
           break
 
         case OP.OP_DROP:
@@ -707,7 +793,11 @@ export default class Spend {
               'OP_DROP requires at least one item to be on the stack.'
             )
           }
-          this.stack.pop()
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
           break
 
         case OP.OP_DUP:
@@ -717,6 +807,7 @@ export default class Spend {
             )
           }
           this.stack.push([...this.stacktop(-1)])
+          this.stackMem += this.stacktop(-1).length
           break
 
         case OP.OP_NIP:
@@ -726,6 +817,7 @@ export default class Spend {
             )
           }
           this.stack.splice(this.stack.length - 2, 1)
+          this.stackMem -= this.stacktop(-1).length
           break
 
         case OP.OP_OVER:
@@ -735,6 +827,7 @@ export default class Spend {
             )
           }
           this.stack.push([...this.stacktop(-2)])
+          this.stackMem += this.stacktop(-2).length
           break
 
         case OP.OP_PICK:
@@ -747,7 +840,11 @@ export default class Spend {
           buf = this.stacktop(-1)
           bn = BigNumber.fromScriptNum(buf, requireMinimalPush)
           n = bn.toNumber()
-          this.stack.pop()
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
           if (n < 0 || n >= this.stack.length) {
             this.scriptEvaluationError(
               `${OP[currentOpcode] as string} requires the top stack element to be 0 or a positive number less than the current size of the stack.`
@@ -756,8 +853,10 @@ export default class Spend {
           buf = this.stacktop(-n - 1)
           if (currentOpcode === OP.OP_ROLL) {
             this.stack.splice(this.stack.length - n - 1, 1)
+            this.stackMem -= buf.length
           }
           this.stack.push([...buf])
+          this.stackMem += buf.length
           break
 
         case OP.OP_ROT:
@@ -793,6 +892,7 @@ export default class Spend {
             )
           }
           this.stack.splice(this.stack.length - 2, 0, [...this.stacktop(-1)])
+          this.stackMem += this.stacktop(-1).length
           break
 
         case OP.OP_SIZE:
@@ -803,6 +903,7 @@ export default class Spend {
           }
           bn = new BigNumber(this.stacktop(-1).length)
           this.stack.push(bn.toScriptNum())
+          this.stackMem += bn.toScriptNum().length
           break
 
         case OP.OP_AND:
@@ -841,7 +942,11 @@ export default class Spend {
           }
 
           // And pop vch2.
-          this.stack.pop()
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
           break
 
         case OP.OP_INVERT:
@@ -865,7 +970,11 @@ export default class Spend {
           }
           buf1 = this.stacktop(-2)
           if (buf1.length === 0) {
-            this.stack.pop()
+            poppedValue = this.stack.pop()
+            if (poppedValue != null) {
+              this.stackMem -= poppedValue.length
+            }
+            clearPoppedValue()
           } else {
             bn1 = new BigNumber(buf1)
             bn2 = BigNumber.fromScriptNum(
@@ -878,8 +987,16 @@ export default class Spend {
                 `${OP[currentOpcode] as string} requires the top item on the stack not to be negative.`
               )
             }
-            this.stack.pop()
-            this.stack.pop()
+            poppedValue = this.stack.pop()
+            if (poppedValue != null) {
+              this.stackMem -= poppedValue.length
+            }
+            clearPoppedValue()
+            poppedValue = this.stack.pop()
+            if (poppedValue != null) {
+              this.stackMem -= poppedValue.length
+            }
+            clearPoppedValue()
             let shifted
             if (currentOpcode === OP.OP_LSHIFT) {
               shifted = bn1.ushln(n)
@@ -892,6 +1009,7 @@ export default class Spend {
               buf1.length
             )
             this.stack.push(bufShifted)
+            this.stackMem += bufShifted.length
           }
           break
 
@@ -905,12 +1023,25 @@ export default class Spend {
           buf1 = this.stacktop(-2)
           buf2 = this.stacktop(-1)
           fEqual = toHex(buf1) === toHex(buf2)
-          this.stack.pop()
-          this.stack.pop()
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
           this.stack.push(fEqual ? [1] : [])
+          this.stackMem += (fEqual ? 1 : 0)
           if (currentOpcode === OP.OP_EQUALVERIFY) {
-            if (fEqual) {
-              this.stack.pop()
+            if (this.castToBool(this.stacktop(-1))) {
+              poppedValue = this.stack.pop()
+              if (poppedValue != null) {
+                this.stackMem -= poppedValue.length
+              }
+              clearPoppedValue()
             } else {
               this.scriptEvaluationError(
                 'OP_EQUALVERIFY requires the top two stack items to be equal.'
@@ -954,8 +1085,13 @@ export default class Spend {
               bn = new BigNumber(bn.cmpn(0) !== 0 ? 1 : 0 + 0)
               break
           }
-          this.stack.pop()
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
           this.stack.push(bn.toScriptNum())
+          this.stackMem += bn.toScriptNum().length
           break
 
         case OP.OP_ADD:
@@ -1043,13 +1179,26 @@ export default class Spend {
               bn = bn1.cmp(bn2) > 0 ? bn1 : bn2
               break
           }
-          this.stack.pop()
-          this.stack.pop()
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
           this.stack.push(bn.toScriptNum())
+          this.stackMem += bn.toScriptNum().length
 
           if (currentOpcode === OP.OP_NUMEQUALVERIFY) {
             if (this.castToBool(this.stacktop(-1))) {
-              this.stack.pop()
+              poppedValue = this.stack.pop()
+              if (poppedValue != null) {
+                this.stackMem -= poppedValue.length
+              }
+              clearPoppedValue()
             } else {
               this.scriptEvaluationError(
                 'OP_NUMEQUALVERIFY requires the top stack item to be truthy.'
@@ -1068,10 +1217,23 @@ export default class Spend {
           bn2 = BigNumber.fromScriptNum(this.stacktop(-2), requireMinimalPush)
           bn3 = BigNumber.fromScriptNum(this.stacktop(-1), requireMinimalPush)
           fValue = bn2.cmp(bn1) <= 0 && bn1.cmp(bn3) < 0
-          this.stack.pop()
-          this.stack.pop()
-          this.stack.pop()
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
           this.stack.push(fValue ? [1] : [])
+          this.stackMem += (fValue ? 1 : 0)
           break
 
         case OP.OP_RIPEMD160:
@@ -1085,7 +1247,7 @@ export default class Spend {
             )
           }
 
-          let bufHash: number[] = [] // ✅ Initialize bufHash to an empty array
+          let bufHash: number[] = [] // Initialize bufHash to an empty array
           buf = this.stacktop(-1)
           if (currentOpcode === OP.OP_RIPEMD160) {
             bufHash = Hash.ripemd160(buf)
@@ -1099,8 +1261,13 @@ export default class Spend {
             bufHash = Hash.hash256(buf)
           }
 
-          this.stack.pop()
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
           this.stack.push(bufHash)
+          this.stackMem += bufHash.length
           break
         }
 
@@ -1158,14 +1325,27 @@ export default class Spend {
             )
           }
 
-          this.stack.pop()
-          this.stack.pop()
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
 
           // stack.push_back(fSuccess ? vchTrue : vchFalse);
           this.stack.push(fSuccess ? [1] : [])
+          this.stackMem += (fSuccess ? 1 : 0)
           if (currentOpcode === OP.OP_CHECKSIGVERIFY) {
             if (fSuccess) {
-              this.stack.pop()
+              poppedValue = this.stack.pop()
+              if (poppedValue != null) {
+                this.stackMem -= poppedValue.length
+              }
+              clearPoppedValue()
             } else {
               this.scriptEvaluationError(
                 'OP_CHECKSIGVERIFY requires that a valid signature is provided.'
@@ -1293,7 +1473,11 @@ export default class Spend {
               ikey2--
             }
 
-            this.stack.pop()
+            poppedValue = this.stack.pop()
+            if (poppedValue != null) {
+              this.stackMem -= poppedValue.length
+            }
+            clearPoppedValue()
           }
 
           // A bug causes CHECKMULTISIG to consume one extra argument
@@ -1313,13 +1497,22 @@ export default class Spend {
               `${OP[currentOpcode] as string} requires the extra stack item to be empty.`
             )
           }
-          this.stack.pop()
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
 
           this.stack.push(fSuccess ? [1] : [])
+          this.stackMem += (fSuccess ? 1 : 0)
 
           if (currentOpcode === OP.OP_CHECKMULTISIGVERIFY) {
             if (fSuccess) {
-              this.stack.pop()
+              poppedValue = this.stack.pop()
+              if (poppedValue != null) {
+                this.stackMem -= poppedValue.length
+              }
+              clearPoppedValue()
             } else {
               this.scriptEvaluationError(
                 'OP_CHECKMULTISIGVERIFY requires that a sufficient number of valid signatures are provided.'
@@ -1343,7 +1536,14 @@ export default class Spend {
             )
           }
           this.stack[this.stack.length - 2] = [...buf1, ...buf2]
-          this.stack.pop()
+          this.stackMem -= buf1.length
+          this.stackMem -= buf2.length
+          this.stackMem += buf1.length + buf2.length
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
           break
 
         case OP.OP_SPLIT:
@@ -1372,7 +1572,10 @@ export default class Spend {
 
           // Replace existing stack values by the new values.
           this.stack[this.stack.length - 2] = buf2.slice(0, n)
+          this.stackMem -= buf1.length
+          this.stackMem += n
           this.stack[this.stack.length - 1] = buf2.slice(n)
+          this.stackMem += buf1.length - n
           break
 
         case OP.OP_NUM2BIN:
@@ -1392,7 +1595,11 @@ export default class Spend {
             )
           }
 
-          this.stack.pop()
+          poppedValue = this.stack.pop()
+          if (poppedValue != null) {
+            this.stackMem -= poppedValue.length
+          }
+          clearPoppedValue()
           rawnum = this.stacktop(-1)
 
           // Try to see if we can fit that number in the number of
@@ -1431,6 +1638,8 @@ export default class Spend {
           num[n] = signbit
 
           this.stack[this.stack.length - 1] = num
+          this.stackMem -= rawnum.length
+          this.stackMem += size
           break
 
         case OP.OP_BIN2NUM:
@@ -1444,6 +1653,8 @@ export default class Spend {
           buf2 = minimallyEncode(buf1)
 
           this.stack[this.stack.length - 1] = buf2
+          this.stackMem -= buf1.length
+          this.stackMem += buf2.length
 
           // The resulting number must be a valid number.
           if (!isMinimallyEncoded(buf2)) {
@@ -1460,6 +1671,7 @@ export default class Spend {
 
     // Finally, increment the program counter
     this.programCounter++
+    return true
   }
 
   /**
@@ -1479,8 +1691,7 @@ export default class Spend {
         'Unlocking scripts can only contain push operations, and no other opcodes.'
       )
     }
-    while (true) {
-      this.step()
+    while (this.step()) {
       if (
         this.context === 'LockingScript' &&
         this.programCounter >= this.lockingScript.chunks.length