@bsv/sdk 1.3.13 → 1.3.14

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

@@ -1,49 +1,11 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const Script_1 = __importDefault(require("./Script"));
-const BigNumber_1 = __importDefault(require("../primitives/BigNumber"));
-const OP_17 = __importDefault(require("./OP"));
-const utils_1 = require("../primitives/utils");
-const Hash = __importStar(require("../primitives/Hash"));
-const TransactionSignature_1 = __importDefault(require("../primitives/TransactionSignature"));
-const PublicKey_1 = __importDefault(require("../primitives/PublicKey"));
-const ECDSA_1 = require("../primitives/ECDSA");
+import Script from './Script.js';
+import BigNumber from '../primitives/BigNumber.js';
+import OP from './OP.js';
+import { toHex, minimallyEncode } from '../primitives/utils.js';
+import * as Hash from '../primitives/Hash.js';
+import TransactionSignature from '../primitives/TransactionSignature.js';
+import PublicKey from '../primitives/PublicKey.js';
+import { verify } from '../primitives/ECDSA.js';
 // These constants control the current behavior of the interpreter.
 // In the future, all of them will go away.
 const maxScriptElementSize = 1024 * 1024 * 1024;
@@ -70,7 +32,7 @@ const requireCleanStack = true;
  * @property {UnlockingScript} unlockingScript - The unlocking script that unlocks the UTXO for spending.
  * @property {number} inputSequence - The sequence number of this input.
  */
-class Spend {
+export default class Spend {
     sourceTXID;
     sourceOutputIndex;
     sourceSatoshis;
@@ -157,11 +119,11 @@ class Spend {
             operation = this.lockingScript.chunks[this.programCounter];
         }
         const isOpcodeDisabled = (op) => {
-            return (op === OP_17.default.OP_2MUL ||
-                op === OP_17.default.OP_2DIV ||
-                op === OP_17.default.OP_VERIF ||
-                op === OP_17.default.OP_VERNOTIF ||
-                op === OP_17.default.OP_VER);
+            return (op === OP.OP_2MUL ||
+                op === OP.OP_2DIV ||
+                op === OP.OP_VERIF ||
+                op === OP.OP_VERNOTIF ||
+                op === OP.OP_VER);
         };
         const isChunkMinimal = (chunk) => {
             const data = chunk.data;
@@ -171,15 +133,15 @@ class Spend {
             }
             if (data.length === 0) {
                 // Could have used OP_0.
-                return op === OP_17.default.OP_0;
+                return op === OP.OP_0;
             }
             else if (data.length === 1 && data[0] >= 1 && data[0] <= 16) {
                 // Could have used OP_1 .. OP_16.
-                return op === OP_17.default.OP_1 + (data[0] - 1);
+                return op === OP.OP_1 + (data[0] - 1);
             }
             else if (data.length === 1 && data[0] === 0x81) {
                 // Could have used OP_1NEGATE.
-                return op === OP_17.default.OP_1NEGATE;
+                return op === OP.OP_1NEGATE;
             }
             else if (data.length <= 75) {
                 // Could have used a direct push (opCode indicating number of bytes pushed + those bytes).
@@ -187,11 +149,11 @@ class Spend {
             }
             else if (data.length <= 255) {
                 // Could have used OP_PUSHDATA.
-                return op === OP_17.default.OP_PUSHDATA1;
+                return op === OP.OP_PUSHDATA1;
             }
             else if (data.length <= 65535) {
                 // Could have used OP_PUSHDATA2.
-                return op === OP_17.default.OP_PUSHDATA2;
+                return op === OP.OP_PUSHDATA2;
             }
             return true;
         };
@@ -311,11 +273,11 @@ class Spend {
             if (!isChecksigFormat(buf)) {
                 this.scriptEvaluationError('The signature format is invalid.');
             }
-            const sig = TransactionSignature_1.default.fromChecksigFormat(buf);
+            const sig = TransactionSignature.fromChecksigFormat(buf);
             if (requireLowSSignatures && !sig.hasLowS()) {
                 this.scriptEvaluationError('The signature must have a low S value.');
             }
-            if ((sig.scope & TransactionSignature_1.default.SIGHASH_FORKID) === 0) {
+            if ((sig.scope & TransactionSignature.SIGHASH_FORKID) === 0) {
                 this.scriptEvaluationError('The signature must use SIGHASH_FORKID.');
                 return false;
             }
@@ -341,7 +303,7 @@ class Spend {
             return true;
         };
         const verifySignature = (sig, pubkey, subscript) => {
-            const preimage = TransactionSignature_1.default.format({
+            const preimage = TransactionSignature.format({
                 sourceTXID: this.sourceTXID,
                 sourceOutputIndex: this.sourceOutputIndex,
                 sourceSatoshis: this.sourceSatoshis,
@@ -354,11 +316,11 @@ class Spend {
                 lockTime: this.lockTime,
                 scope: sig.scope
             });
-            const hash = new BigNumber_1.default(Hash.hash256(preimage));
-            return (0, ECDSA_1.verify)(hash, sig, pubkey);
+            const hash = new BigNumber(Hash.hash256(preimage));
+            return verify(hash, sig, pubkey);
         };
         const isScriptExecuting = !this.ifStack.includes(false);
-        let buf, buf1, buf2, buf3, spliced, n, size, rawnum, num, signbit, x1, x2, x3, bn, bn1, bn2, bn3, bufSig, bufPubkey, subscript, bufHash;
+        let buf, buf1, buf2, buf3, spliced, n, size, rawnum, num, signbit, x1, x2, x3, bn, bn1, bn2, bn3, bufSig, bufPubkey, subscript;
         let sig, pubkey, i, fOk, nKeysCount, ikey, ikey2, nSigsCount, isig;
         let fValue, fEqual, fSuccess;
         // Read instruction
@@ -375,7 +337,7 @@ class Spend {
         }
         if (isScriptExecuting &&
             currentOpcode >= 0 &&
-            currentOpcode <= OP_17.default.OP_PUSHDATA4) {
+            currentOpcode <= OP.OP_PUSHDATA4) {
             if (requireMinimalPush && !isChunkMinimal(operation)) {
                 this.scriptEvaluationError('This data is not minimally-encoded.');
             }
@@ -387,107 +349,107 @@ class Spend {
             }
         }
         else if (isScriptExecuting ||
-            (OP_17.default.OP_IF <= currentOpcode && currentOpcode <= OP_17.default.OP_ENDIF)) {
+            (OP.OP_IF <= currentOpcode && currentOpcode <= OP.OP_ENDIF)) {
             switch (currentOpcode) {
-                case OP_17.default.OP_1NEGATE:
-                case OP_17.default.OP_1:
-                case OP_17.default.OP_2:
-                case OP_17.default.OP_3:
-                case OP_17.default.OP_4:
-                case OP_17.default.OP_5:
-                case OP_17.default.OP_6:
-                case OP_17.default.OP_7:
-                case OP_17.default.OP_8:
-                case OP_17.default.OP_9:
-                case OP_17.default.OP_10:
-                case OP_17.default.OP_11:
-                case OP_17.default.OP_12:
-                case OP_17.default.OP_13:
-                case OP_17.default.OP_14:
-                case OP_17.default.OP_15:
-                case OP_17.default.OP_16:
-                    n = currentOpcode - (OP_17.default.OP_1 - 1);
-                    buf = new BigNumber_1.default(n).toScriptNum();
+                case OP.OP_1NEGATE:
+                case OP.OP_1:
+                case OP.OP_2:
+                case OP.OP_3:
+                case OP.OP_4:
+                case OP.OP_5:
+                case OP.OP_6:
+                case OP.OP_7:
+                case OP.OP_8:
+                case OP.OP_9:
+                case OP.OP_10:
+                case OP.OP_11:
+                case OP.OP_12:
+                case OP.OP_13:
+                case OP.OP_14:
+                case OP.OP_15:
+                case OP.OP_16:
+                    n = currentOpcode - (OP.OP_1 - 1);
+                    buf = new BigNumber(n).toScriptNum();
                     this.stack.push(buf);
                     break;
-                case OP_17.default.OP_NOP:
-                case OP_17.default.OP_NOP2:
-                case OP_17.default.OP_NOP3:
-                case OP_17.default.OP_NOP1:
-                case OP_17.default.OP_NOP4:
-                case OP_17.default.OP_NOP5:
-                case OP_17.default.OP_NOP6:
-                case OP_17.default.OP_NOP7:
-                case OP_17.default.OP_NOP8:
-                case OP_17.default.OP_NOP9:
-                case OP_17.default.OP_NOP10:
-                case OP_17.default.OP_NOP11:
-                case OP_17.default.OP_NOP12:
-                case OP_17.default.OP_NOP13:
-                case OP_17.default.OP_NOP14:
-                case OP_17.default.OP_NOP15:
-                case OP_17.default.OP_NOP16:
-                case OP_17.default.OP_NOP17:
-                case OP_17.default.OP_NOP18:
-                case OP_17.default.OP_NOP19:
-                case OP_17.default.OP_NOP20:
-                case OP_17.default.OP_NOP21:
-                case OP_17.default.OP_NOP22:
-                case OP_17.default.OP_NOP23:
-                case OP_17.default.OP_NOP24:
-                case OP_17.default.OP_NOP25:
-                case OP_17.default.OP_NOP26:
-                case OP_17.default.OP_NOP27:
-                case OP_17.default.OP_NOP28:
-                case OP_17.default.OP_NOP29:
-                case OP_17.default.OP_NOP30:
-                case OP_17.default.OP_NOP31:
-                case OP_17.default.OP_NOP32:
-                case OP_17.default.OP_NOP33:
-                case OP_17.default.OP_NOP34:
-                case OP_17.default.OP_NOP35:
-                case OP_17.default.OP_NOP36:
-                case OP_17.default.OP_NOP37:
-                case OP_17.default.OP_NOP38:
-                case OP_17.default.OP_NOP39:
-                case OP_17.default.OP_NOP40:
-                case OP_17.default.OP_NOP41:
-                case OP_17.default.OP_NOP42:
-                case OP_17.default.OP_NOP43:
-                case OP_17.default.OP_NOP44:
-                case OP_17.default.OP_NOP45:
-                case OP_17.default.OP_NOP46:
-                case OP_17.default.OP_NOP47:
-                case OP_17.default.OP_NOP48:
-                case OP_17.default.OP_NOP49:
-                case OP_17.default.OP_NOP50:
-                case OP_17.default.OP_NOP51:
-                case OP_17.default.OP_NOP52:
-                case OP_17.default.OP_NOP53:
-                case OP_17.default.OP_NOP54:
-                case OP_17.default.OP_NOP55:
-                case OP_17.default.OP_NOP56:
-                case OP_17.default.OP_NOP57:
-                case OP_17.default.OP_NOP58:
-                case OP_17.default.OP_NOP59:
-                case OP_17.default.OP_NOP60:
-                case OP_17.default.OP_NOP61:
-                case OP_17.default.OP_NOP62:
-                case OP_17.default.OP_NOP63:
-                case OP_17.default.OP_NOP64:
-                case OP_17.default.OP_NOP65:
-                case OP_17.default.OP_NOP66:
-                case OP_17.default.OP_NOP67:
-                case OP_17.default.OP_NOP68:
-                case OP_17.default.OP_NOP69:
-                case OP_17.default.OP_NOP70:
-                case OP_17.default.OP_NOP71:
-                case OP_17.default.OP_NOP72:
-                case OP_17.default.OP_NOP73:
-                case OP_17.default.OP_NOP77:
+                case OP.OP_NOP:
+                case OP.OP_NOP2:
+                case OP.OP_NOP3:
+                case OP.OP_NOP1:
+                case OP.OP_NOP4:
+                case OP.OP_NOP5:
+                case OP.OP_NOP6:
+                case OP.OP_NOP7:
+                case OP.OP_NOP8:
+                case OP.OP_NOP9:
+                case OP.OP_NOP10:
+                case OP.OP_NOP11:
+                case OP.OP_NOP12:
+                case OP.OP_NOP13:
+                case OP.OP_NOP14:
+                case OP.OP_NOP15:
+                case OP.OP_NOP16:
+                case OP.OP_NOP17:
+                case OP.OP_NOP18:
+                case OP.OP_NOP19:
+                case OP.OP_NOP20:
+                case OP.OP_NOP21:
+                case OP.OP_NOP22:
+                case OP.OP_NOP23:
+                case OP.OP_NOP24:
+                case OP.OP_NOP25:
+                case OP.OP_NOP26:
+                case OP.OP_NOP27:
+                case OP.OP_NOP28:
+                case OP.OP_NOP29:
+                case OP.OP_NOP30:
+                case OP.OP_NOP31:
+                case OP.OP_NOP32:
+                case OP.OP_NOP33:
+                case OP.OP_NOP34:
+                case OP.OP_NOP35:
+                case OP.OP_NOP36:
+                case OP.OP_NOP37:
+                case OP.OP_NOP38:
+                case OP.OP_NOP39:
+                case OP.OP_NOP40:
+                case OP.OP_NOP41:
+                case OP.OP_NOP42:
+                case OP.OP_NOP43:
+                case OP.OP_NOP44:
+                case OP.OP_NOP45:
+                case OP.OP_NOP46:
+                case OP.OP_NOP47:
+                case OP.OP_NOP48:
+                case OP.OP_NOP49:
+                case OP.OP_NOP50:
+                case OP.OP_NOP51:
+                case OP.OP_NOP52:
+                case OP.OP_NOP53:
+                case OP.OP_NOP54:
+                case OP.OP_NOP55:
+                case OP.OP_NOP56:
+                case OP.OP_NOP57:
+                case OP.OP_NOP58:
+                case OP.OP_NOP59:
+                case OP.OP_NOP60:
+                case OP.OP_NOP61:
+                case OP.OP_NOP62:
+                case OP.OP_NOP63:
+                case OP.OP_NOP64:
+                case OP.OP_NOP65:
+                case OP.OP_NOP66:
+                case OP.OP_NOP67:
+                case OP.OP_NOP68:
+                case OP.OP_NOP69:
+                case OP.OP_NOP70:
+                case OP.OP_NOP71:
+                case OP.OP_NOP72:
+                case OP.OP_NOP73:
+                case OP.OP_NOP77:
                     break;
-                case OP_17.default.OP_IF:
-                case OP_17.default.OP_NOTIF:
+                case OP.OP_IF:
+                case OP.OP_NOTIF:
                     fValue = false;
                     if (isScriptExecuting) {
                         if (this.stack.length < 1) {
@@ -495,27 +457,27 @@ class Spend {
                         }
                         buf = this.stacktop(-1);
                         fValue = this.castToBool(buf);
-                        if (currentOpcode === OP_17.default.OP_NOTIF) {
+                        if (currentOpcode === OP.OP_NOTIF) {
                             fValue = !fValue;
                         }
                         this.stack.pop();
                     }
                     this.ifStack.push(fValue);
                     break;
-                case OP_17.default.OP_ELSE:
+                case OP.OP_ELSE:
                     if (this.ifStack.length === 0) {
                         this.scriptEvaluationError('OP_ELSE requires a preceeding OP_IF.');
                     }
                     this.ifStack[this.ifStack.length - 1] =
                         !this.ifStack[this.ifStack.length - 1];
                     break;
-                case OP_17.default.OP_ENDIF:
+                case OP.OP_ENDIF:
                     if (this.ifStack.length === 0) {
                         this.scriptEvaluationError('OP_ENDIF requires a preceeding OP_IF.');
                     }
                     this.ifStack.pop();
                     break;
-                case OP_17.default.OP_VERIFY:
+                case OP.OP_VERIFY:
                     if (this.stack.length < 1) {
                         this.scriptEvaluationError('OP_VERIFY requires at least one item to be on the stack.');
                     }
@@ -528,7 +490,7 @@ class Spend {
                         this.scriptEvaluationError('OP_VERIFY requires the top stack value to be truthy.');
                     }
                     break;
-                case OP_17.default.OP_RETURN:
+                case OP.OP_RETURN:
                     if (this.context === 'UnlockingScript') {
                         this.programCounter = this.unlockingScript.chunks.length;
                     }
@@ -537,26 +499,26 @@ class Spend {
                     }
                     this.ifStack = [];
                     break;
-                case OP_17.default.OP_TOALTSTACK:
+                case OP.OP_TOALTSTACK:
                     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());
+                    this.altStack.push(this.stack.pop() ?? []);
                     break;
-                case OP_17.default.OP_FROMALTSTACK:
+                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());
+                    this.stack.push(this.altStack.pop() ?? []);
                     break;
-                case OP_17.default.OP_2DROP:
+                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();
                     break;
-                case OP_17.default.OP_2DUP:
+                case OP.OP_2DUP:
                     if (this.stack.length < 2) {
                         this.scriptEvaluationError('OP_2DUP requires at least two items to be on the stack.');
                     }
@@ -565,7 +527,7 @@ class Spend {
                     this.stack.push([...buf1]);
                     this.stack.push([...buf2]);
                     break;
-                case OP_17.default.OP_3DUP:
+                case OP.OP_3DUP:
                     if (this.stack.length < 3) {
                         this.scriptEvaluationError('OP_3DUP requires at least three items to be on the stack.');
                     }
@@ -576,7 +538,7 @@ class Spend {
                     this.stack.push([...buf2]);
                     this.stack.push([...buf3]);
                     break;
-                case OP_17.default.OP_2OVER:
+                case OP.OP_2OVER:
                     if (this.stack.length < 4) {
                         this.scriptEvaluationError('OP_2OVER requires at least four items to be on the stack.');
                     }
@@ -585,7 +547,7 @@ class Spend {
                     this.stack.push([...buf1]);
                     this.stack.push([...buf2]);
                     break;
-                case OP_17.default.OP_2ROT:
+                case OP.OP_2ROT:
                     if (this.stack.length < 6) {
                         this.scriptEvaluationError('OP_2ROT requires at least six items to be on the stack.');
                     }
@@ -593,7 +555,7 @@ class Spend {
                     this.stack.push(spliced[0]);
                     this.stack.push(spliced[1]);
                     break;
-                case OP_17.default.OP_2SWAP:
+                case OP.OP_2SWAP:
                     if (this.stack.length < 4) {
                         this.scriptEvaluationError('OP_2SWAP requires at least four items to be on the stack.');
                     }
@@ -601,7 +563,7 @@ class Spend {
                     this.stack.push(spliced[0]);
                     this.stack.push(spliced[1]);
                     break;
-                case OP_17.default.OP_IFDUP:
+                case OP.OP_IFDUP:
                     if (this.stack.length < 1) {
                         this.scriptEvaluationError('OP_IFDUP requires at least one item to be on the stack.');
                     }
@@ -611,53 +573,53 @@ class Spend {
                         this.stack.push([...buf]);
                     }
                     break;
-                case OP_17.default.OP_DEPTH:
-                    buf = new BigNumber_1.default(this.stack.length).toScriptNum();
+                case OP.OP_DEPTH:
+                    buf = new BigNumber(this.stack.length).toScriptNum();
                     this.stack.push(buf);
                     break;
-                case OP_17.default.OP_DROP:
+                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();
                     break;
-                case OP_17.default.OP_DUP:
+                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)]);
                     break;
-                case OP_17.default.OP_NIP:
+                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);
                     break;
-                case OP_17.default.OP_OVER:
+                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)]);
                     break;
-                case OP_17.default.OP_PICK:
-                case OP_17.default.OP_ROLL:
+                case OP.OP_PICK:
+                case OP.OP_ROLL:
                     if (this.stack.length < 2) {
-                        this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires at least two items to be on the stack.`);
+                        this.scriptEvaluationError(`${OP[currentOpcode]} requires at least two items to be on the stack.`);
                     }
                     buf = this.stacktop(-1);
-                    bn = BigNumber_1.default.fromScriptNum(buf, requireMinimalPush);
+                    bn = BigNumber.fromScriptNum(buf, requireMinimalPush);
                     n = bn.toNumber();
                     this.stack.pop();
                     if (n < 0 || n >= this.stack.length) {
-                        this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires the top stack element to be 0 or a positive number less than the current size of the stack.`);
+                        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_17.default.OP_ROLL) {
+                    if (currentOpcode === OP.OP_ROLL) {
                         this.stack.splice(this.stack.length - n - 1, 1);
                     }
                     this.stack.push([...buf]);
                     break;
-                case OP_17.default.OP_ROT:
+                case OP.OP_ROT:
                     if (this.stack.length < 3) {
                         this.scriptEvaluationError('OP_ROT requires at least three items to be on the stack.');
                     }
@@ -668,7 +630,7 @@ class Spend {
                     this.stack[this.stack.length - 2] = x3;
                     this.stack[this.stack.length - 1] = x1;
                     break;
-                case OP_17.default.OP_SWAP:
+                case OP.OP_SWAP:
                     if (this.stack.length < 2) {
                         this.scriptEvaluationError('OP_SWAP requires at least two items to be on the stack.');
                     }
@@ -677,42 +639,42 @@ class Spend {
                     this.stack[this.stack.length - 2] = x2;
                     this.stack[this.stack.length - 1] = x1;
                     break;
-                case OP_17.default.OP_TUCK:
+                case OP.OP_TUCK:
                     if (this.stack.length < 2) {
                         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)]);
                     break;
-                case OP_17.default.OP_SIZE:
+                case OP.OP_SIZE:
                     if (this.stack.length < 1) {
                         this.scriptEvaluationError('OP_SIZE requires at least one item to be on the stack.');
                     }
-                    bn = new BigNumber_1.default(this.stacktop(-1).length);
+                    bn = new BigNumber(this.stacktop(-1).length);
                     this.stack.push(bn.toScriptNum());
                     break;
-                case OP_17.default.OP_AND:
-                case OP_17.default.OP_OR:
-                case OP_17.default.OP_XOR:
+                case OP.OP_AND:
+                case OP.OP_OR:
+                case OP.OP_XOR:
                     if (this.stack.length < 2) {
-                        this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires at least one item to be on the stack.`);
+                        this.scriptEvaluationError(`${OP[currentOpcode]} requires at least one item to be on the stack.`);
                     }
                     buf1 = this.stacktop(-2);
                     buf2 = this.stacktop(-1);
                     if (buf1.length !== buf2.length) {
-                        this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires the top two stack items to be the same size.`);
+                        this.scriptEvaluationError(`${OP[currentOpcode]} requires the top two stack items to be the same size.`);
                     }
                     switch (currentOpcode) {
-                        case OP_17.default.OP_AND:
+                        case OP.OP_AND:
                             for (let i = 0; i < buf1.length; i++) {
                                 buf1[i] &= buf2[i];
                             }
                             break;
-                        case OP_17.default.OP_OR:
+                        case OP.OP_OR:
                             for (let i = 0; i < buf1.length; i++) {
                                 buf1[i] |= buf2[i];
                             }
                             break;
-                        case OP_17.default.OP_XOR:
+                        case OP.OP_XOR:
                             for (let i = 0; i < buf1.length; i++) {
                                 buf1[i] ^= buf2[i];
                             }
@@ -721,7 +683,7 @@ class Spend {
                     // And pop vch2.
                     this.stack.pop();
                     break;
-                case OP_17.default.OP_INVERT:
+                case OP.OP_INVERT:
                     if (this.stack.length < 1) {
                         this.scriptEvaluationError('OP_INVERT requires at least one item to be on the stack.');
                     }
@@ -730,47 +692,47 @@ class Spend {
                         buf[i] = ~buf[i];
                     }
                     break;
-                case OP_17.default.OP_LSHIFT:
-                case OP_17.default.OP_RSHIFT:
+                case OP.OP_LSHIFT:
+                case OP.OP_RSHIFT:
                     if (this.stack.length < 2) {
-                        this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires at least two items to be on the stack.`);
+                        this.scriptEvaluationError(`${OP[currentOpcode]} requires at least two items to be on the stack.`);
                     }
                     buf1 = this.stacktop(-2);
                     if (buf1.length === 0) {
                         this.stack.pop();
                     }
                     else {
-                        bn1 = new BigNumber_1.default(buf1);
-                        bn2 = BigNumber_1.default.fromScriptNum(this.stacktop(-1), requireMinimalPush);
+                        bn1 = new BigNumber(buf1);
+                        bn2 = BigNumber.fromScriptNum(this.stacktop(-1), requireMinimalPush);
                         n = bn2.toNumber();
                         if (n < 0) {
-                            this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires the top item on the stack not to be negative.`);
+                            this.scriptEvaluationError(`${OP[currentOpcode]} requires the top item on the stack not to be negative.`);
                         }
                         this.stack.pop();
                         this.stack.pop();
                         let shifted;
-                        if (currentOpcode === OP_17.default.OP_LSHIFT) {
+                        if (currentOpcode === OP.OP_LSHIFT) {
                             shifted = bn1.ushln(n);
                         }
-                        if (currentOpcode === OP_17.default.OP_RSHIFT) {
+                        if (currentOpcode === OP.OP_RSHIFT) {
                             shifted = bn1.ushrn(n);
                         }
                         const bufShifted = padDataToSize(shifted.toArray().slice(buf1.length * -1), buf1.length);
                         this.stack.push(bufShifted);
                     }
                     break;
-                case OP_17.default.OP_EQUAL:
-                case OP_17.default.OP_EQUALVERIFY:
+                case OP.OP_EQUAL:
+                case OP.OP_EQUALVERIFY:
                     if (this.stack.length < 2) {
-                        this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires at least two items to be on the stack.`);
+                        this.scriptEvaluationError(`${OP[currentOpcode]} requires at least two items to be on the stack.`);
                     }
                     buf1 = this.stacktop(-2);
                     buf2 = this.stacktop(-1);
-                    fEqual = (0, utils_1.toHex)(buf1) === (0, utils_1.toHex)(buf2);
+                    fEqual = toHex(buf1) === toHex(buf2);
                     this.stack.pop();
                     this.stack.pop();
                     this.stack.push(fEqual ? [1] : []);
-                    if (currentOpcode === OP_17.default.OP_EQUALVERIFY) {
+                    if (currentOpcode === OP.OP_EQUALVERIFY) {
                         if (fEqual) {
                             this.stack.pop();
                         }
@@ -779,124 +741,124 @@ class Spend {
                         }
                     }
                     break;
-                case OP_17.default.OP_1ADD:
-                case OP_17.default.OP_1SUB:
-                case OP_17.default.OP_NEGATE:
-                case OP_17.default.OP_ABS:
-                case OP_17.default.OP_NOT:
-                case OP_17.default.OP_0NOTEQUAL:
+                case OP.OP_1ADD:
+                case OP.OP_1SUB:
+                case OP.OP_NEGATE:
+                case OP.OP_ABS:
+                case OP.OP_NOT:
+                case OP.OP_0NOTEQUAL:
                     if (this.stack.length < 1) {
-                        this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires at least one items to be on the stack.`);
+                        this.scriptEvaluationError(`${OP[currentOpcode]} requires at least one items to be on the stack.`);
                     }
                     buf = this.stacktop(-1);
-                    bn = BigNumber_1.default.fromScriptNum(buf, requireMinimalPush);
+                    bn = BigNumber.fromScriptNum(buf, requireMinimalPush);
                     switch (currentOpcode) {
-                        case OP_17.default.OP_1ADD:
+                        case OP.OP_1ADD:
                             bn = bn.addn(1);
                             break;
-                        case OP_17.default.OP_1SUB:
+                        case OP.OP_1SUB:
                             bn = bn.subn(1);
                             break;
-                        case OP_17.default.OP_NEGATE:
+                        case OP.OP_NEGATE:
                             bn = bn.neg();
                             break;
-                        case OP_17.default.OP_ABS:
+                        case OP.OP_ABS:
                             if (bn.cmpn(0) < 0) {
                                 bn = bn.neg();
                             }
                             break;
-                        case OP_17.default.OP_NOT:
-                            bn = new BigNumber_1.default(bn.cmpn(0) === 0 ? 1 : 0 + 0);
+                        case OP.OP_NOT:
+                            bn = new BigNumber(bn.cmpn(0) === 0 ? 1 : 0 + 0);
                             break;
-                        case OP_17.default.OP_0NOTEQUAL:
-                            bn = new BigNumber_1.default(bn.cmpn(0) !== 0 ? 1 : 0 + 0);
+                        case OP.OP_0NOTEQUAL:
+                            bn = new BigNumber(bn.cmpn(0) !== 0 ? 1 : 0 + 0);
                             break;
                     }
                     this.stack.pop();
                     this.stack.push(bn.toScriptNum());
                     break;
-                case OP_17.default.OP_ADD:
-                case OP_17.default.OP_SUB:
-                case OP_17.default.OP_MUL:
-                case OP_17.default.OP_MOD:
-                case OP_17.default.OP_DIV:
-                case OP_17.default.OP_BOOLAND:
-                case OP_17.default.OP_BOOLOR:
-                case OP_17.default.OP_NUMEQUAL:
-                case OP_17.default.OP_NUMEQUALVERIFY:
-                case OP_17.default.OP_NUMNOTEQUAL:
-                case OP_17.default.OP_LESSTHAN:
-                case OP_17.default.OP_GREATERTHAN:
-                case OP_17.default.OP_LESSTHANOREQUAL:
-                case OP_17.default.OP_GREATERTHANOREQUAL:
-                case OP_17.default.OP_MIN:
-                case OP_17.default.OP_MAX:
+                case OP.OP_ADD:
+                case OP.OP_SUB:
+                case OP.OP_MUL:
+                case OP.OP_MOD:
+                case OP.OP_DIV:
+                case OP.OP_BOOLAND:
+                case OP.OP_BOOLOR:
+                case OP.OP_NUMEQUAL:
+                case OP.OP_NUMEQUALVERIFY:
+                case OP.OP_NUMNOTEQUAL:
+                case OP.OP_LESSTHAN:
+                case OP.OP_GREATERTHAN:
+                case OP.OP_LESSTHANOREQUAL:
+                case OP.OP_GREATERTHANOREQUAL:
+                case OP.OP_MIN:
+                case OP.OP_MAX:
                     if (this.stack.length < 2) {
-                        this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires at least two items to be on the stack.`);
+                        this.scriptEvaluationError(`${OP[currentOpcode]} requires at least two items to be on the stack.`);
                     }
-                    bn1 = BigNumber_1.default.fromScriptNum(this.stacktop(-2), requireMinimalPush);
-                    bn2 = BigNumber_1.default.fromScriptNum(this.stacktop(-1), requireMinimalPush);
-                    bn = new BigNumber_1.default(0);
+                    bn1 = BigNumber.fromScriptNum(this.stacktop(-2), requireMinimalPush);
+                    bn2 = BigNumber.fromScriptNum(this.stacktop(-1), requireMinimalPush);
+                    bn = new BigNumber(0);
                     switch (currentOpcode) {
-                        case OP_17.default.OP_ADD:
+                        case OP.OP_ADD:
                             bn = bn1.add(bn2);
                             break;
-                        case OP_17.default.OP_SUB:
+                        case OP.OP_SUB:
                             bn = bn1.sub(bn2);
                             break;
-                        case OP_17.default.OP_MUL:
+                        case OP.OP_MUL:
                             bn = bn1.mul(bn2);
                             break;
-                        case OP_17.default.OP_DIV:
+                        case OP.OP_DIV:
                             if (bn2.cmpn(0) === 0) {
                                 this.scriptEvaluationError('OP_DIV cannot divide by zero!');
                             }
                             bn = bn1.div(bn2);
                             break;
-                        case OP_17.default.OP_MOD:
+                        case OP.OP_MOD:
                             if (bn2.cmpn(0) === 0) {
                                 this.scriptEvaluationError('OP_MOD cannot divide by zero!');
                             }
                             bn = bn1.mod(bn2);
                             break;
-                        case OP_17.default.OP_BOOLAND:
-                            bn = new BigNumber_1.default(bn1.cmpn(0) !== 0 && bn2.cmpn(0) !== 0 ? 1 : 0 + 0);
+                        case OP.OP_BOOLAND:
+                            bn = new BigNumber(bn1.cmpn(0) !== 0 && bn2.cmpn(0) !== 0 ? 1 : 0 + 0);
                             break;
-                        case OP_17.default.OP_BOOLOR:
-                            bn = new BigNumber_1.default(bn1.cmpn(0) !== 0 || bn2.cmpn(0) !== 0 ? 1 : 0 + 0);
+                        case OP.OP_BOOLOR:
+                            bn = new BigNumber(bn1.cmpn(0) !== 0 || bn2.cmpn(0) !== 0 ? 1 : 0 + 0);
                             break;
-                        case OP_17.default.OP_NUMEQUAL:
-                            bn = new BigNumber_1.default(bn1.cmp(bn2) === 0 ? 1 : 0 + 0);
+                        case OP.OP_NUMEQUAL:
+                            bn = new BigNumber(bn1.cmp(bn2) === 0 ? 1 : 0 + 0);
                             break;
-                        case OP_17.default.OP_NUMEQUALVERIFY:
-                            bn = new BigNumber_1.default(bn1.cmp(bn2) === 0 ? 1 : 0 + 0);
+                        case OP.OP_NUMEQUALVERIFY:
+                            bn = new BigNumber(bn1.cmp(bn2) === 0 ? 1 : 0 + 0);
                             break;
-                        case OP_17.default.OP_NUMNOTEQUAL:
-                            bn = new BigNumber_1.default(bn1.cmp(bn2) !== 0 ? 1 : 0 + 0);
+                        case OP.OP_NUMNOTEQUAL:
+                            bn = new BigNumber(bn1.cmp(bn2) !== 0 ? 1 : 0 + 0);
                             break;
-                        case OP_17.default.OP_LESSTHAN:
-                            bn = new BigNumber_1.default(bn1.cmp(bn2) < 0 ? 1 : 0 + 0);
+                        case OP.OP_LESSTHAN:
+                            bn = new BigNumber(bn1.cmp(bn2) < 0 ? 1 : 0 + 0);
                             break;
-                        case OP_17.default.OP_GREATERTHAN:
-                            bn = new BigNumber_1.default(bn1.cmp(bn2) > 0 ? 1 : 0 + 0);
+                        case OP.OP_GREATERTHAN:
+                            bn = new BigNumber(bn1.cmp(bn2) > 0 ? 1 : 0 + 0);
                             break;
-                        case OP_17.default.OP_LESSTHANOREQUAL:
-                            bn = new BigNumber_1.default(bn1.cmp(bn2) <= 0 ? 1 : 0 + 0);
+                        case OP.OP_LESSTHANOREQUAL:
+                            bn = new BigNumber(bn1.cmp(bn2) <= 0 ? 1 : 0 + 0);
                             break;
-                        case OP_17.default.OP_GREATERTHANOREQUAL:
-                            bn = new BigNumber_1.default(bn1.cmp(bn2) >= 0 ? 1 : 0 + 0);
+                        case OP.OP_GREATERTHANOREQUAL:
+                            bn = new BigNumber(bn1.cmp(bn2) >= 0 ? 1 : 0 + 0);
                             break;
-                        case OP_17.default.OP_MIN:
+                        case OP.OP_MIN:
                             bn = bn1.cmp(bn2) < 0 ? bn1 : bn2;
                             break;
-                        case OP_17.default.OP_MAX:
+                        case OP.OP_MAX:
                             bn = bn1.cmp(bn2) > 0 ? bn1 : bn2;
                             break;
                     }
                     this.stack.pop();
                     this.stack.pop();
                     this.stack.push(bn.toScriptNum());
-                    if (currentOpcode === OP_17.default.OP_NUMEQUALVERIFY) {
+                    if (currentOpcode === OP.OP_NUMEQUALVERIFY) {
                         if (this.castToBool(this.stacktop(-1))) {
                             this.stack.pop();
                         }
@@ -905,73 +867,75 @@ class Spend {
                         }
                     }
                     break;
-                case OP_17.default.OP_WITHIN:
+                case OP.OP_WITHIN:
                     if (this.stack.length < 3) {
                         this.scriptEvaluationError('OP_WITHIN requires at least three items to be on the stack.');
                     }
-                    bn1 = BigNumber_1.default.fromScriptNum(this.stacktop(-3), requireMinimalPush);
-                    bn2 = BigNumber_1.default.fromScriptNum(this.stacktop(-2), requireMinimalPush);
-                    bn3 = BigNumber_1.default.fromScriptNum(this.stacktop(-1), requireMinimalPush);
+                    bn1 = BigNumber.fromScriptNum(this.stacktop(-3), requireMinimalPush);
+                    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();
                     this.stack.push(fValue ? [1] : []);
                     break;
-                case OP_17.default.OP_RIPEMD160:
-                case OP_17.default.OP_SHA1:
-                case OP_17.default.OP_SHA256:
-                case OP_17.default.OP_HASH160:
-                case OP_17.default.OP_HASH256:
+                case OP.OP_RIPEMD160:
+                case OP.OP_SHA1:
+                case OP.OP_SHA256:
+                case OP.OP_HASH160:
+                case OP.OP_HASH256: {
                     if (this.stack.length < 1) {
-                        this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires at least one item to be on the stack.`);
+                        this.scriptEvaluationError(`${OP[currentOpcode]} requires at least one item to be on the stack.`);
                     }
+                    let bufHash = []; // ✅ Initialize bufHash to an empty array
                     buf = this.stacktop(-1);
-                    if (currentOpcode === OP_17.default.OP_RIPEMD160) {
+                    if (currentOpcode === OP.OP_RIPEMD160) {
                         bufHash = Hash.ripemd160(buf);
                     }
-                    else if (currentOpcode === OP_17.default.OP_SHA1) {
+                    else if (currentOpcode === OP.OP_SHA1) {
                         bufHash = Hash.sha1(buf);
                     }
-                    else if (currentOpcode === OP_17.default.OP_SHA256) {
+                    else if (currentOpcode === OP.OP_SHA256) {
                         bufHash = Hash.sha256(buf);
                     }
-                    else if (currentOpcode === OP_17.default.OP_HASH160) {
+                    else if (currentOpcode === OP.OP_HASH160) {
                         bufHash = Hash.hash160(buf);
                     }
-                    else if (currentOpcode === OP_17.default.OP_HASH256) {
+                    else if (currentOpcode === OP.OP_HASH256) {
                         bufHash = Hash.hash256(buf);
                     }
                     this.stack.pop();
                     this.stack.push(bufHash);
                     break;
-                case OP_17.default.OP_CODESEPARATOR:
+                }
+                case OP.OP_CODESEPARATOR:
                     this.lastCodeSeparator = this.programCounter;
                     break;
-                case OP_17.default.OP_CHECKSIG:
-                case OP_17.default.OP_CHECKSIGVERIFY:
+                case OP.OP_CHECKSIG:
+                case OP.OP_CHECKSIGVERIFY:
                     if (this.stack.length < 2) {
-                        this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires at least two items to be on the stack.`);
+                        this.scriptEvaluationError(`${OP[currentOpcode]} requires at least two items to be on the stack.`);
                     }
                     bufSig = this.stacktop(-2);
                     bufPubkey = this.stacktop(-1);
                     if (!checkSignatureEncoding(bufSig) ||
                         !checkPublicKeyEncoding(bufPubkey)) {
-                        this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires correct encoding for the public key and signature.`);
+                        this.scriptEvaluationError(`${OP[currentOpcode]} requires correct encoding for the public key and signature.`);
                     }
                     // Subset of script starting at the most recent codeseparator
                     // CScript scriptCode(pbegincodehash, pend);
                     if (this.context === 'UnlockingScript') {
-                        subscript = new Script_1.default(this.unlockingScript.chunks.slice(this.lastCodeSeparator));
+                        subscript = new Script(this.unlockingScript.chunks.slice(this.lastCodeSeparator ?? 0));
                     }
                     else {
-                        subscript = new Script_1.default(this.lockingScript.chunks.slice(this.lastCodeSeparator));
+                        subscript = new Script(this.lockingScript.chunks.slice(this.lastCodeSeparator ?? 0));
                     }
                     // Drop the signature, since there's no way for a signature to sign itself
-                    subscript.findAndDelete(new Script_1.default().writeBin(bufSig));
+                    subscript.findAndDelete(new Script().writeBin(bufSig));
                     try {
-                        sig = TransactionSignature_1.default.fromChecksigFormat(bufSig);
-                        pubkey = PublicKey_1.default.fromDER(bufPubkey);
+                        sig = TransactionSignature.fromChecksigFormat(bufSig);
+                        pubkey = PublicKey.fromDER(bufPubkey);
                         fSuccess = verifySignature(sig, pubkey, subscript);
                     }
                     catch (e) {
@@ -979,13 +943,13 @@ class Spend {
                         fSuccess = false;
                     }
                     if (!fSuccess && bufSig.length > 0) {
-                        this.scriptEvaluationError(`${OP_17.default[currentOpcode]} failed to verify the signature, and requires an empty signature when verification fails.`);
+                        this.scriptEvaluationError(`${OP[currentOpcode]} failed to verify the signature, and requires an empty signature when verification fails.`);
                     }
                     this.stack.pop();
                     this.stack.pop();
                     // stack.push_back(fSuccess ? vchTrue : vchFalse);
                     this.stack.push(fSuccess ? [1] : []);
-                    if (currentOpcode === OP_17.default.OP_CHECKSIGVERIFY) {
+                    if (currentOpcode === OP.OP_CHECKSIGVERIFY) {
                         if (fSuccess) {
                             this.stack.pop();
                         }
@@ -994,16 +958,16 @@ class Spend {
                         }
                     }
                     break;
-                case OP_17.default.OP_CHECKMULTISIG:
-                case OP_17.default.OP_CHECKMULTISIGVERIFY:
+                case OP.OP_CHECKMULTISIG:
+                case OP.OP_CHECKMULTISIGVERIFY:
                     i = 1;
                     if (this.stack.length < i) {
-                        this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires at least 1 item to be on the stack.`);
+                        this.scriptEvaluationError(`${OP[currentOpcode]} requires at least 1 item to be on the stack.`);
                     }
-                    nKeysCount = BigNumber_1.default.fromScriptNum(this.stacktop(-i), requireMinimalPush).toNumber();
+                    nKeysCount = BigNumber.fromScriptNum(this.stacktop(-i), requireMinimalPush).toNumber();
                     // TODO: Keys and opcount are parameterized in client. No magic numbers!
                     if (nKeysCount < 0 || nKeysCount > maxMultisigKeyCount) {
-                        this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires a key count between 0 and ${maxMultisigKeyCount}.`);
+                        this.scriptEvaluationError(`${OP[currentOpcode]} requires a key count between 0 and ${maxMultisigKeyCount}.`);
                     }
                     ikey = ++i;
                     i += nKeysCount;
@@ -1013,28 +977,28 @@ class Spend {
                     // operation fails.
                     ikey2 = nKeysCount + 2;
                     if (this.stack.length < i) {
-                        this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires the number of stack items not to be less than the number of keys used.`);
+                        this.scriptEvaluationError(`${OP[currentOpcode]} requires the number of stack items not to be less than the number of keys used.`);
                     }
-                    nSigsCount = BigNumber_1.default.fromScriptNum(this.stacktop(-i), requireMinimalPush).toNumber();
+                    nSigsCount = BigNumber.fromScriptNum(this.stacktop(-i), requireMinimalPush).toNumber();
                     if (nSigsCount < 0 || nSigsCount > nKeysCount) {
-                        this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires the number of signatures to be no greater than the number of keys.`);
+                        this.scriptEvaluationError(`${OP[currentOpcode]} requires the number of signatures to be no greater than the number of keys.`);
                     }
                     isig = ++i;
                     i += nSigsCount;
                     if (this.stack.length < i) {
-                        this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires the number of stack items not to be less than the number of signatures provided.`);
+                        this.scriptEvaluationError(`${OP[currentOpcode]} requires the number of stack items not to be less than the number of signatures provided.`);
                     }
                     // Subset of script starting at the most recent codeseparator
                     if (this.context === 'UnlockingScript') {
-                        subscript = new Script_1.default(this.unlockingScript.chunks.slice(this.lastCodeSeparator));
+                        subscript = new Script(this.unlockingScript.chunks.slice(this.lastCodeSeparator ?? 0));
                     }
                     else {
-                        subscript = new Script_1.default(this.lockingScript.chunks.slice(this.lastCodeSeparator));
+                        subscript = new Script(this.lockingScript.chunks.slice(this.lastCodeSeparator ?? 0));
                     }
                     // Drop the signatures, since there's no way for a signature to sign itself
                     for (let k = 0; k < nSigsCount; k++) {
                         bufSig = this.stacktop(-isig - k);
-                        subscript.findAndDelete(new Script_1.default().writeBin(bufSig));
+                        subscript.findAndDelete(new Script().writeBin(bufSig));
                     }
                     fSuccess = true;
                     while (fSuccess && nSigsCount > 0) {
@@ -1044,11 +1008,11 @@ class Spend {
                         bufPubkey = this.stacktop(-ikey);
                         if (!checkSignatureEncoding(bufSig) ||
                             !checkPublicKeyEncoding(bufPubkey)) {
-                            this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires correct encoding for the public key and signature.`);
+                            this.scriptEvaluationError(`${OP[currentOpcode]} requires correct encoding for the public key and signature.`);
                         }
                         try {
-                            sig = TransactionSignature_1.default.fromChecksigFormat(bufSig);
-                            pubkey = PublicKey_1.default.fromString((0, utils_1.toHex)(bufPubkey));
+                            sig = TransactionSignature.fromChecksigFormat(bufSig);
+                            pubkey = PublicKey.fromString(toHex(bufPubkey));
                             fOk = verifySignature(sig, pubkey, subscript);
                         }
                         catch (e) {
@@ -1069,8 +1033,8 @@ class Spend {
                     }
                     // Clean up stack of actual arguments
                     while (i-- > 1) {
-                        if (!fSuccess && !ikey2 && this.stacktop(-1).length > 0) {
-                            this.scriptEvaluationError(`${OP_17.default[currentOpcode]} failed to verify a signature, and requires an empty signature when verification fails.`);
+                        if (!fSuccess && ikey2 === 0 && this.stacktop(-1).length > 0) {
+                            this.scriptEvaluationError(`${OP[currentOpcode]} failed to verify a signature, and requires an empty signature when verification fails.`);
                         }
                         if (ikey2 > 0) {
                             ikey2--;
@@ -1084,15 +1048,15 @@ class Spend {
                     // so optionally verify it is exactly equal to zero prior
                     // to removing it from the stack.
                     if (this.stack.length < 1) {
-                        this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires an extra item to be on the stack.`);
+                        this.scriptEvaluationError(`${OP[currentOpcode]} requires an extra item to be on the stack.`);
                     }
                     if (this.stacktop(-1).length > 0) {
                         // NOTE: Is this necessary? We don't care about malleability.
-                        this.scriptEvaluationError(`${OP_17.default[currentOpcode]} requires the extra stack item to be empty.`);
+                        this.scriptEvaluationError(`${OP[currentOpcode]} requires the extra stack item to be empty.`);
                     }
                     this.stack.pop();
                     this.stack.push(fSuccess ? [1] : []);
-                    if (currentOpcode === OP_17.default.OP_CHECKMULTISIGVERIFY) {
+                    if (currentOpcode === OP.OP_CHECKMULTISIGVERIFY) {
                         if (fSuccess) {
                             this.stack.pop();
                         }
@@ -1101,7 +1065,7 @@ class Spend {
                         }
                     }
                     break;
-                case OP_17.default.OP_CAT:
+                case OP.OP_CAT:
                     if (this.stack.length < 2) {
                         this.scriptEvaluationError('OP_CAT requires at least two items to be on the stack.');
                     }
@@ -1113,13 +1077,13 @@ class Spend {
                     this.stack[this.stack.length - 2] = [...buf1, ...buf2];
                     this.stack.pop();
                     break;
-                case OP_17.default.OP_SPLIT:
+                case OP.OP_SPLIT:
                     if (this.stack.length < 2) {
                         this.scriptEvaluationError('OP_SPLIT requires at least two items to be on the stack.');
                     }
                     buf1 = this.stacktop(-2);
                     // Make sure the split point is apropriate.
-                    n = BigNumber_1.default.fromScriptNum(this.stacktop(-1), requireMinimalPush).toNumber();
+                    n = BigNumber.fromScriptNum(this.stacktop(-1), requireMinimalPush).toNumber();
                     if (n < 0 || n > buf1.length) {
                         this.scriptEvaluationError('OP_SPLIT requires the first stack item to be a non-negative number less than or equal to the size of the second-from-top stack item.');
                     }
@@ -1131,11 +1095,11 @@ class Spend {
                     this.stack[this.stack.length - 2] = buf2.slice(0, n);
                     this.stack[this.stack.length - 1] = buf2.slice(n);
                     break;
-                case OP_17.default.OP_NUM2BIN:
+                case OP.OP_NUM2BIN:
                     if (this.stack.length < 2) {
                         this.scriptEvaluationError('OP_NUM2BIN requires at least two items to be on the stack.');
                     }
-                    size = BigNumber_1.default.fromScriptNum(this.stacktop(-1), requireMinimalPush).toNumber();
+                    size = BigNumber.fromScriptNum(this.stacktop(-1), requireMinimalPush).toNumber();
                     if (size > maxScriptElementSize) {
                         this.scriptEvaluationError(`It's not currently possible to push data larger than ${maxScriptElementSize} bytes.`);
                     }
@@ -1143,7 +1107,7 @@ class Spend {
                     rawnum = this.stacktop(-1);
                     // Try to see if we can fit that number in the number of
                     // byte requested.
-                    rawnum = (0, utils_1.minimallyEncode)(rawnum);
+                    rawnum = minimallyEncode(rawnum);
                     if (rawnum.length > size) {
                         this.scriptEvaluationError('OP_NUM2BIN requires that the size expressed in the top stack item is large enough to hold the value expressed in the second-from-top stack item.');
                     }
@@ -1170,12 +1134,12 @@ class Spend {
                     num[n] = signbit;
                     this.stack[this.stack.length - 1] = num;
                     break;
-                case OP_17.default.OP_BIN2NUM:
+                case OP.OP_BIN2NUM:
                     if (this.stack.length < 1) {
                         this.scriptEvaluationError('OP_BIN2NUM requires at least one item to be on the stack.');
                     }
                     buf1 = this.stacktop(-1);
-                    buf2 = (0, utils_1.minimallyEncode)(buf1);
+                    buf2 = minimallyEncode(buf1);
                     this.stack[this.stack.length - 1] = buf2;
                     // The resulting number must be a valid number.
                     if (!isMinimallyEncoded(buf2)) {
@@ -1243,5 +1207,4 @@ class Spend {
         throw new Error(`Script evaluation error: ${str}\n\nSource TXID: ${this.sourceTXID}\nSource output index: ${this.sourceOutputIndex}\nContext: ${this.context}\nProgram counter: ${this.programCounter}\nStack size: ${this.stack.length}\nAlt stack size: ${this.altStack.length}`);
     }
 }
-exports.default = Spend;
 //# sourceMappingURL=Spend.js.map