@bsv/sdk 1.4.20 → 1.4.22

package/dist/esm/src/script/Spend.js

@@ -31,6 +31,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;
@@ -50,6 +51,9 @@ export default class Spend {
     stack;
     altStack;
     ifStack;
+    memoryLimit;
+    stackMem;
+    altStackMem;
     /**
      * @constructor
      * Constructs the Spend object with necessary transaction details.
@@ -79,6 +83,7 @@ export default class Spend {
      *   inputIndex: 0, // inputIndex
      *   unlockingScript: UnlockingScript.fromASM("3045... 02ab..."),
      *   inputSequence: 0xffffffff // inputSequence
+     *   memoryLimit: 100000 // memoryLimit
      * });
      */
     constructor(params) {
@@ -93,6 +98,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();
     }
     reset() {
@@ -102,8 +110,24 @@ export default class Spend {
         this.stack = [];
         this.altStack = [];
         this.ifStack = [];
+        this.stackMem = 0;
+        this.altStackMem = 0;
     }
     step() {
+        let poppedValue;
+        // 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 = () => {
+            poppedValue = undefined;
+        };
         // If the context is UnlockingScript and we have reached the end,
         // set the context to LockingScript and zero the program counter
         if (this.context === 'UnlockingScript' &&
@@ -233,6 +257,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;
@@ -250,6 +278,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;
@@ -343,9 +375,11 @@ 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 ||
@@ -371,6 +405,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:
                 case OP.OP_NOP2:
@@ -460,7 +495,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;
@@ -483,10 +522,12 @@ export default class Spend {
                     }
                     buf = this.stacktop(-1);
                     fValue = this.castToBool(buf);
-                    if (fValue) {
-                        this.stack.pop();
+                    poppedValue = this.stack.pop();
+                    if (poppedValue != null) {
+                        this.stackMem -= poppedValue.length;
                     }
-                    else {
+                    clearPoppedValue();
+                    if (!fValue) {
                         this.scriptEvaluationError('OP_VERIFY requires the top stack value to be truthy.');
                     }
                     break;
@@ -503,20 +544,40 @@ export default class Spend {
                     if (this.stack.length < 1) {
                         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:
                     if (this.altStack.length < 1) {
                         this.scriptEvaluationError('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:
                     if (this.stack.length < 2) {
                         this.scriptEvaluationError('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:
                     if (this.stack.length < 2) {
@@ -525,7 +586,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:
                     if (this.stack.length < 3) {
@@ -535,8 +598,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:
                     if (this.stack.length < 4) {
@@ -545,7 +611,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:
                     if (this.stack.length < 6) {
@@ -553,7 +621,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:
                     if (this.stack.length < 4) {
@@ -561,7 +631,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:
                     if (this.stack.length < 1) {
@@ -571,35 +643,44 @@ 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:
                     if (this.stack.length < 1) {
                         this.scriptEvaluationError('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:
                     if (this.stack.length < 1) {
                         this.scriptEvaluationError('OP_DUP requires at least one item to be on the stack.');
                     }
                     this.stack.push([...this.stacktop(-1)]);
+                    this.stackMem += this.stacktop(-1).length;
                     break;
                 case OP.OP_NIP:
                     if (this.stack.length < 2) {
                         this.scriptEvaluationError('OP_NIP requires at least two items to be on the stack.');
                     }
                     this.stack.splice(this.stack.length - 2, 1);
+                    this.stackMem -= this.stacktop(-1).length;
                     break;
                 case OP.OP_OVER:
                     if (this.stack.length < 2) {
                         this.scriptEvaluationError('OP_OVER requires at least two items to be on the stack.');
                     }
                     this.stack.push([...this.stacktop(-2)]);
+                    this.stackMem += this.stacktop(-2).length;
                     break;
                 case OP.OP_PICK:
                 case OP.OP_ROLL:
@@ -609,15 +690,21 @@ 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]} requires the top stack element to be 0 or a positive number less than the current size of the stack.`);
                     }
                     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:
                     if (this.stack.length < 3) {
@@ -644,6 +731,7 @@ export default class Spend {
                         this.scriptEvaluationError('OP_TUCK requires at least two items to be on the stack.');
                     }
                     this.stack.splice(this.stack.length - 2, 0, [...this.stacktop(-1)]);
+                    this.stackMem += this.stacktop(-1).length;
                     break;
                 case OP.OP_SIZE:
                     if (this.stack.length < 1) {
@@ -651,6 +739,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:
                 case OP.OP_OR:
@@ -681,7 +770,11 @@ export default class Spend {
                             break;
                     }
                     // And pop vch2.
-                    this.stack.pop();
+                    poppedValue = this.stack.pop();
+                    if (poppedValue != null) {
+                        this.stackMem -= poppedValue.length;
+                    }
+                    clearPoppedValue();
                     break;
                 case OP.OP_INVERT:
                     if (this.stack.length < 1) {
@@ -699,7 +792,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);
@@ -708,8 +805,16 @@ export default class Spend {
                         if (n < 0) {
                             this.scriptEvaluationError(`${OP[currentOpcode]} 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);
@@ -719,6 +824,7 @@ export default class Spend {
                         }
                         const bufShifted = padDataToSize(shifted.toArray().slice(buf1.length * -1), buf1.length);
                         this.stack.push(bufShifted);
+                        this.stackMem += bufShifted.length;
                     }
                     break;
                 case OP.OP_EQUAL:
@@ -729,12 +835,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.');
@@ -774,8 +893,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:
                 case OP.OP_SUB:
@@ -855,12 +979,25 @@ 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.');
@@ -875,10 +1012,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:
                 case OP.OP_SHA1:
@@ -888,7 +1038,7 @@ export default class Spend {
                     if (this.stack.length < 1) {
                         this.scriptEvaluationError(`${OP[currentOpcode]} requires at least one item to be on the stack.`);
                     }
-                    let bufHash = []; // ✅ Initialize bufHash to an empty array
+                    let bufHash = []; // Initialize bufHash to an empty array
                     buf = this.stacktop(-1);
                     if (currentOpcode === OP.OP_RIPEMD160) {
                         bufHash = Hash.ripemd160(buf);
@@ -905,8 +1055,13 @@ export default class Spend {
                     else if (currentOpcode === OP.OP_HASH256) {
                         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;
                 }
                 case OP.OP_CODESEPARATOR:
@@ -945,13 +1100,26 @@ export default class Spend {
                     if (!fSuccess && bufSig.length > 0) {
                         this.scriptEvaluationError(`${OP[currentOpcode]} failed to verify the signature, and requires an empty signature when verification fails.`);
                     }
-                    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.');
@@ -1039,7 +1207,11 @@ export default class Spend {
                         if (ikey2 > 0) {
                             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
                     // whose contents were not checked in any way.
@@ -1054,11 +1226,20 @@ export default class Spend {
                         // NOTE: Is this necessary? We don't care about malleability.
                         this.scriptEvaluationError(`${OP[currentOpcode]} 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.');
@@ -1075,7 +1256,14 @@ export default class Spend {
                         this.scriptEvaluationError(`It's not currently possible to push data larger than ${maxScriptElementSize} bytes.`);
                     }
                     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:
                     if (this.stack.length < 2) {
@@ -1093,7 +1281,10 @@ export default class Spend {
                     buf2 = [...buf1];
                     // 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:
                     if (this.stack.length < 2) {
@@ -1103,7 +1294,11 @@ export default class Spend {
                     if (size > maxScriptElementSize) {
                         this.scriptEvaluationError(`It's not currently possible to push data larger than ${maxScriptElementSize} bytes.`);
                     }
-                    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
                     // byte requested.
@@ -1133,6 +1328,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:
                     if (this.stack.length < 1) {
@@ -1141,6 +1338,8 @@ export default class Spend {
                     buf1 = this.stacktop(-1);
                     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)) {
                         this.scriptEvaluationError('OP_BIN2NUM requires that the resulting number is valid.');
@@ -1152,6 +1351,7 @@ export default class Spend {
         }
         // Finally, increment the program counter
         this.programCounter++;
+        return true;
     }
     /**
      * @method validate
@@ -1168,8 +1368,7 @@ export default class Spend {
         if (requirePushOnlyUnlockingScripts && !this.unlockingScript.isPushOnly()) {
             this.scriptEvaluationError('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) {
                 break;