xpi-ts 0.2.13 → 0.2.15

package/dist/cjs/lib/bitcore/script/interpreter.js

@@ -1,1757 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Interpreter = void 0;
-const script_js_1 = require("../script.js");
-const opcode_js_1 = require("../opcode.js");
-const bn_js_1 = require("../crypto/bn.js");
-const hash_js_1 = require("../crypto/hash.js");
-const signature_js_1 = require("../crypto/signature.js");
-const publickey_js_1 = require("../publickey.js");
-const ecdsa_js_1 = require("../crypto/ecdsa.js");
-const schnorr_js_1 = require("../crypto/schnorr.js");
-const preconditions_js_1 = require("../util/preconditions.js");
-const taproot_js_1 = require("../taproot.js");
-class Interpreter {
-    static SCRIPT_VERIFY_NONE = 0;
-    static SCRIPT_VERIFY_P2SH = 1 << 0;
-    static SCRIPT_VERIFY_STRICTENC = 1 << 1;
-    static SCRIPT_VERIFY_DERSIG = 1 << 2;
-    static SCRIPT_VERIFY_LOW_S = 1 << 3;
-    static SCRIPT_VERIFY_NULLDUMMY = 1 << 4;
-    static SCRIPT_VERIFY_SIGPUSHONLY = 1 << 5;
-    static SCRIPT_VERIFY_MINIMALDATA = 1 << 6;
-    static SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS = 1 << 7;
-    static SCRIPT_VERIFY_CLEANSTACK = 1 << 8;
-    static SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY = 1 << 9;
-    static SCRIPT_VERIFY_CHECKSEQUENCEVERIFY = 1 << 10;
-    static SCRIPT_VERIFY_MINIMALIF = 1 << 13;
-    static SCRIPT_VERIFY_NULLFAIL = 1 << 14;
-    static SCRIPT_VERIFY_COMPRESSED_PUBKEYTYPE = 1 << 15;
-    static SCRIPT_ENABLE_SIGHASH_FORKID = 1 << 16;
-    static SCRIPT_ENABLE_REPLAY_PROTECTION = 1 << 17;
-    static SCRIPT_ENABLE_CHECKDATASIG = 1 << 18;
-    static SCRIPT_DISALLOW_SEGWIT_RECOVERY = 1 << 20;
-    static SCRIPT_ENABLE_SCHNORR_MULTISIG = 1 << 21;
-    static SCRIPT_VERIFY_INPUT_SIGCHECKS = 1 << 22;
-    static SCRIPT_TAPROOT_KEY_SPEND_PATH = 1 << 23;
-    static SCRIPT_DISABLE_TAPROOT_SIGHASH_LOTUS = 1 << 24;
-    static MAX_SCRIPT_ELEMENT_SIZE = 520;
-    static MAX_SCRIPT_SIZE = 10000;
-    static MAX_STACK_SIZE = 1000;
-    static MAX_OPCODE_COUNT = 201;
-    static false = Buffer.from([0]);
-    static true = Buffer.from([1]);
-    static MAXIMUM_ELEMENT_SIZE = 4;
-    static LOCKTIME_THRESHOLD = 500000000;
-    static LOCKTIME_THRESHOLD_BN = new bn_js_1.BN(500000000);
-    static SEQUENCE_LOCKTIME_DISABLE_FLAG = 1 << 31;
-    static SEQUENCE_LOCKTIME_TYPE_FLAG = 1 << 22;
-    static SEQUENCE_LOCKTIME_MASK = 0x0000ffff;
-    script;
-    tx;
-    nin;
-    flags;
-    satoshisBN;
-    outputScript;
-    stack = [];
-    altstack = [];
-    pc = 0;
-    pbegincodehash = 0;
-    nOpCount = 0;
-    vfExec = [];
-    errstr = '';
-    constructor(obj) {
-        this.initialize();
-        if (obj) {
-            this.set(obj);
-        }
-    }
-    static create(obj) {
-        return new Interpreter(obj);
-    }
-    initialize() {
-        this.stack = [];
-        this.altstack = [];
-        this.pc = 0;
-        this.pbegincodehash = 0;
-        this.nOpCount = 0;
-        this.vfExec = [];
-        this.errstr = '';
-        this.flags = Interpreter.SCRIPT_VERIFY_NONE;
-    }
-    set(obj) {
-        this.script = obj.script || this.script;
-        this.tx = obj.tx || this.tx;
-        this.nin = obj.nin !== undefined ? obj.nin : this.nin;
-        this.flags = obj.flags !== undefined ? obj.flags : this.flags;
-        this.satoshisBN = obj.satoshisBN || this.satoshisBN;
-        this.outputScript = obj.outputScript || this.outputScript;
-        this.stack = obj.stack || this.stack;
-        return this;
-    }
-    verify(scriptSig, scriptPubkey, tx, nin, flags, satoshisBN) {
-        preconditions_js_1.Preconditions.checkArgument(scriptSig instanceof script_js_1.Script, 'scriptSig', 'Must be a Script');
-        preconditions_js_1.Preconditions.checkArgument(scriptPubkey instanceof script_js_1.Script, 'scriptPubkey', 'Must be a Script');
-        if (flags && (flags & Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID) !== 0) {
-            flags |= Interpreter.SCRIPT_VERIFY_STRICTENC;
-            if (!satoshisBN) {
-                throw new Error('internal error - need satoshisBN to verify FORKID transactions');
-            }
-        }
-        this.set({
-            script: scriptSig,
-            tx: tx,
-            nin: nin,
-            flags: flags,
-            satoshisBN: satoshisBN,
-        });
-        let stackCopy = [];
-        if ((this.flags & Interpreter.SCRIPT_VERIFY_SIGPUSHONLY) !== 0) {
-            if (!scriptSig.isPushOnly()) {
-                this.errstr = 'SCRIPT_ERR_SIG_PUSHONLY';
-                return false;
-            }
-        }
-        if (!this.evaluate()) {
-            return false;
-        }
-        if (this.flags & Interpreter.SCRIPT_VERIFY_P2SH) {
-            stackCopy = this.stack.slice();
-        }
-        const stack = this.stack;
-        this.initialize();
-        this.script = scriptPubkey;
-        this.stack = stack;
-        this.tx = tx;
-        this.nin = nin;
-        this.flags = flags || Interpreter.SCRIPT_VERIFY_NONE;
-        this.satoshisBN = satoshisBN;
-        const scriptPubkeyBuf = scriptPubkey.toBuffer();
-        if (scriptPubkeyBuf.length > 0 &&
-            scriptPubkeyBuf[0] === opcode_js_1.Opcode.OP_SCRIPTTYPE) {
-            if (!this._verifyScriptType(scriptPubkey)) {
-                return false;
-            }
-            return true;
-        }
-        if (!this.evaluate()) {
-            return false;
-        }
-        if (this.stack.length === 0) {
-            this.errstr = 'SCRIPT_ERR_EVAL_FALSE_NO_RESULT';
-            return false;
-        }
-        const buf = this.stack[this.stack.length - 1];
-        if (!Interpreter.castToBool(buf)) {
-            this.errstr = 'SCRIPT_ERR_EVAL_FALSE_IN_STACK';
-            return false;
-        }
-        if (this.flags & Interpreter.SCRIPT_VERIFY_P2SH &&
-            scriptPubkey.isScriptHashOut()) {
-            if (!scriptSig.isPushOnly()) {
-                this.errstr = 'SCRIPT_ERR_SIG_PUSHONLY';
-                return false;
-            }
-            if (stackCopy.length === 0) {
-                throw new Error('internal error - stack copy empty');
-            }
-            const redeemScriptSerialized = stackCopy[stackCopy.length - 1];
-            const redeemScript = script_js_1.Script.fromBuffer(redeemScriptSerialized);
-            stackCopy.pop();
-            this.initialize();
-            this.script = redeemScript;
-            this.stack = stackCopy;
-            this.tx = tx;
-            this.nin = nin;
-            this.flags = flags || Interpreter.SCRIPT_VERIFY_NONE;
-            this.satoshisBN = satoshisBN;
-            if (!this.evaluate()) {
-                return false;
-            }
-            if (stackCopy.length === 0) {
-                this.errstr = 'SCRIPT_ERR_EVAL_FALSE_NO_P2SH_STACK';
-                return false;
-            }
-            if (!Interpreter.castToBool(stackCopy[stackCopy.length - 1])) {
-                this.errstr = 'SCRIPT_ERR_EVAL_FALSE_IN_P2SH_STACK';
-                return false;
-            }
-        }
-        if ((this.flags & Interpreter.SCRIPT_VERIFY_CLEANSTACK) != 0) {
-            if ((this.flags & Interpreter.SCRIPT_VERIFY_P2SH) == 0) {
-                throw new Error('internal error - CLEANSTACK without P2SH');
-            }
-            if (stackCopy.length != 1) {
-                this.errstr = 'SCRIPT_ERR_CLEANSTACK';
-                return false;
-            }
-        }
-        return true;
-    }
-    checkRawSignatureEncoding(buf) {
-        if (buf.length === 0) {
-            return true;
-        }
-        if (Interpreter.isSchnorrSig(buf)) {
-            return this.checkRawSchnorrSignatureEncoding(buf);
-        }
-        if ((this.flags &
-            (Interpreter.SCRIPT_VERIFY_DERSIG |
-                Interpreter.SCRIPT_VERIFY_LOW_S |
-                Interpreter.SCRIPT_VERIFY_STRICTENC)) !==
-            0 &&
-            !signature_js_1.Signature.isDER(buf)) {
-            this.errstr = 'SCRIPT_ERR_SIG_DER_INVALID_FORMAT';
-            return false;
-        }
-        else if ((this.flags & Interpreter.SCRIPT_VERIFY_LOW_S) !== 0) {
-            const sig = signature_js_1.Signature.fromDER(buf, false);
-            if (!sig.hasLowS()) {
-                this.errstr = 'SCRIPT_ERR_SIG_DER_HIGH_S';
-                return false;
-            }
-        }
-        return true;
-    }
-    checkRawSchnorrSignatureEncoding(buf) {
-        if (buf.length !== 64) {
-            this.errstr = 'SCRIPT_ERR_SIG_NONSCHNORR';
-            return false;
-        }
-        return true;
-    }
-    checkTransactionSchnorrSignatureEncoding(buf) {
-        if (buf.length !== 65) {
-            this.errstr = 'SCRIPT_ERR_SIG_NONSCHNORR';
-            return false;
-        }
-        if (!this.checkRawSchnorrSignatureEncoding(buf.subarray(0, 64))) {
-            return false;
-        }
-        if (!this.checkSighashEncoding(buf)) {
-            return false;
-        }
-        return true;
-    }
-    checkSighashEncoding(buf) {
-        if (buf.length === 0) {
-            return true;
-        }
-        const hashType = buf[buf.length - 1];
-        if (hashType === 0x00) {
-            this.errstr = 'SCRIPT_ERR_SIG_HASHTYPE';
-            return false;
-        }
-        if (this.flags & Interpreter.SCRIPT_TAPROOT_KEY_SPEND_PATH &&
-            (hashType & 0x60) !== 0x60) {
-            this.errstr = 'SCRIPT_ERR_TAPROOT_KEY_SPEND_MUST_USE_LOTUS_SIGHASH';
-            return false;
-        }
-        const usesForkId = (hashType & 0x40) !== 0;
-        const forkIdEnabled = (this.flags & Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID) !== 0;
-        if (!forkIdEnabled && usesForkId) {
-            this.errstr = 'SCRIPT_ERR_ILLEGAL_FORKID';
-            return false;
-        }
-        if (forkIdEnabled && !usesForkId) {
-            this.errstr = 'SCRIPT_ERR_MUST_USE_FORKID';
-            return false;
-        }
-        return true;
-    }
-    checkSignatureEncoding(buf) {
-        if (buf.length === 0) {
-            return true;
-        }
-        try {
-            const sig = signature_js_1.Signature.fromDER(buf);
-            if ((this.flags & Interpreter.SCRIPT_VERIFY_LOW_S) !== 0) {
-                if (sig.s >
-                    new bn_js_1.BN('7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0', 16)) {
-                    this.errstr = 'SCRIPT_ERR_SIG_DER_HIGH_S';
-                    return false;
-                }
-            }
-            const hashType = buf[buf.length - 1];
-            if (hashType < 0x80 || hashType > 0x84) {
-                this.errstr = 'SCRIPT_ERR_SIG_HASHTYPE';
-                return false;
-            }
-            if ((this.flags & Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID) !== 0) {
-                if ((hashType & 0x40) === 0) {
-                    this.errstr = 'SCRIPT_ERR_ILLEGAL_FORKID';
-                    return false;
-                }
-            }
-            else {
-                if ((hashType & 0x40) !== 0) {
-                    this.errstr = 'SCRIPT_ERR_MUST_USE_FORKID';
-                    return false;
-                }
-            }
-            return true;
-        }
-        catch (e) {
-            this.errstr = 'SCRIPT_ERR_SIG_DER_INVALID_FORMAT';
-            return false;
-        }
-    }
-    checkTxSignatureEncoding(buf) {
-        if (buf.length === 0) {
-            return true;
-        }
-        if (Interpreter.isSchnorrSig(buf)) {
-            return this.checkTransactionSchnorrSignatureEncoding(buf);
-        }
-        if (!this.checkRawSignatureEncoding(buf.subarray(0, buf.length - 1))) {
-            return false;
-        }
-        if ((this.flags & Interpreter.SCRIPT_VERIFY_STRICTENC) !== 0) {
-            const sig = signature_js_1.Signature.fromTxFormat(buf);
-            if (!sig.hasDefinedHashtype()) {
-                this.errstr = 'SCRIPT_ERR_SIG_HASHTYPE';
-                return false;
-            }
-            const isTaprootKeyPath = (this.flags & Interpreter.SCRIPT_TAPROOT_KEY_SPEND_PATH) !== 0;
-            if (!isTaprootKeyPath) {
-                if (!(this.flags & Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID) &&
-                    sig.nhashtype & signature_js_1.Signature.SIGHASH_FORKID) {
-                    this.errstr = 'SCRIPT_ERR_ILLEGAL_FORKID';
-                    return false;
-                }
-                if (this.flags & Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID &&
-                    !(sig.nhashtype & signature_js_1.Signature.SIGHASH_FORKID)) {
-                    this.errstr = 'SCRIPT_ERR_MUST_USE_FORKID';
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-    checkDataSignatureEncoding(buf) {
-        if (buf.length === 0) {
-            return true;
-        }
-        return this.checkRawSignatureEncoding(buf);
-    }
-    checkPubkeyEncoding(buf) {
-        if ((this.flags & Interpreter.SCRIPT_VERIFY_STRICTENC) !== 0) {
-            if (!publickey_js_1.PublicKey.isValid(buf) &&
-                !this.isCompressedOrUncompressedPubkey(buf)) {
-                this.errstr = 'SCRIPT_ERR_PUBKEYTYPE';
-                return false;
-            }
-        }
-        return true;
-    }
-    isCompressedOrUncompressedPubkey(buf) {
-        if (buf.length === 33) {
-            return buf[0] === 0x02 || buf[0] === 0x03;
-        }
-        if (buf.length === 65) {
-            return buf[0] === 0x04;
-        }
-        return false;
-    }
-    evaluate() {
-        if (this.script.toBuffer().length > Interpreter.MAX_SCRIPT_SIZE) {
-            this.errstr = 'SCRIPT_ERR_SCRIPT_SIZE';
-            return false;
-        }
-        try {
-            while (this.pc < this.script.chunks.length) {
-                if (this.stack.length > Interpreter.MAX_STACK_SIZE) {
-                    this.errstr = 'SCRIPT_ERR_STACK_SIZE';
-                    return false;
-                }
-                if (!this.step()) {
-                    return false;
-                }
-            }
-            if (this.stack.length + this.altstack.length >
-                Interpreter.MAX_STACK_SIZE) {
-                this.errstr = 'SCRIPT_ERR_STACK_SIZE';
-                return false;
-            }
-            if (this.vfExec.length > 0) {
-                this.errstr = 'SCRIPT_ERR_UNBALANCED_CONDITIONAL';
-                return false;
-            }
-            return true;
-        }
-        catch (e) {
-            this.errstr = 'SCRIPT_ERR_UNKNOWN_ERROR: ' + e.message;
-            return false;
-        }
-    }
-    toScriptNumBuffer(value) {
-        const num = typeof value === 'bigint' ? value : BigInt(value);
-        if (num === 0n) {
-            return Buffer.alloc(0);
-        }
-        const isNegative = num < 0n;
-        const absNum = isNegative ? -num : num;
-        const bytes = [];
-        let temp = absNum;
-        while (temp > 0n) {
-            bytes.push(Number(temp & 0xffn));
-            temp >>= 8n;
-        }
-        if (isNegative) {
-            if (bytes.length > 0 && (bytes[bytes.length - 1] & 0x80) !== 0) {
-                bytes.push(0x80);
-            }
-            else if (bytes.length > 0) {
-                bytes[bytes.length - 1] |= 0x80;
-            }
-            else {
-                bytes.push(0x80);
-            }
-        }
-        return Buffer.from(bytes);
-    }
-    fromScriptNumBuffer(buf) {
-        if (buf.length === 0) {
-            return 0n;
-        }
-        let result = 0n;
-        for (let i = 0; i < buf.length; i++) {
-            result |= BigInt(buf[i]) << BigInt(i * 8);
-        }
-        if (buf.length > 0 && (buf[buf.length - 1] & 0x80) !== 0) {
-            const lastByte = buf[buf.length - 1] & 0x7f;
-            result =
-                (result & ~(0xffn << BigInt((buf.length - 1) * 8))) |
-                    (BigInt(lastByte) << BigInt((buf.length - 1) * 8));
-            result = -result;
-        }
-        return result;
-    }
-    castToBool(buf) {
-        for (let i = 0; i < buf.length; i++) {
-            if (buf[i] !== 0) {
-                if (i === buf.length - 1 && buf[i] === 0x80) {
-                    return false;
-                }
-                return true;
-            }
-        }
-        return false;
-    }
-    step() {
-        if (this.pc >= this.script.chunks.length) {
-            return true;
-        }
-        const chunk = this.script.chunks[this.pc];
-        this.pc++;
-        const opcodenum = chunk.opcodenum;
-        if (opcodenum === undefined) {
-            this.errstr = 'SCRIPT_ERR_UNDEFINED_OPCODE';
-            return false;
-        }
-        if (chunk.buf && chunk.buf.length > Interpreter.MAX_SCRIPT_ELEMENT_SIZE) {
-            this.errstr = 'SCRIPT_ERR_PUSH_SIZE';
-            return false;
-        }
-        if (opcodenum > opcode_js_1.Opcode.OP_16 &&
-            ++this.nOpCount > Interpreter.MAX_OPCODE_COUNT) {
-            this.errstr = 'SCRIPT_ERR_OP_COUNT';
-            return false;
-        }
-        if (this.isOpcodeDisabled(opcodenum)) {
-            this.errstr = 'SCRIPT_ERR_DISABLED_OPCODE';
-            return false;
-        }
-        const fRequireMinimal = (this.flags & Interpreter.SCRIPT_VERIFY_MINIMALDATA) !== 0;
-        const fExec = this.vfExec.indexOf(false) === -1;
-        if (fExec && opcodenum >= 0 && opcodenum <= opcode_js_1.Opcode.OP_PUSHDATA4) {
-            if (fRequireMinimal && !this.script.checkMinimalPush(this.pc - 1)) {
-                this.errstr = 'SCRIPT_ERR_MINIMALDATA';
-                return false;
-            }
-            if (!chunk.buf) {
-                this.stack.push(Interpreter.false);
-            }
-            else if (chunk.len !== chunk.buf.length) {
-                throw new Error('Length of push value not equal to length of data');
-            }
-            else {
-                this.stack.push(chunk.buf);
-            }
-        }
-        else if (fExec ||
-            (opcode_js_1.Opcode.OP_IF <= opcodenum && opcodenum <= opcode_js_1.Opcode.OP_ENDIF)) {
-            switch (opcodenum) {
-                case opcode_js_1.Opcode.OP_1NEGATE: {
-                    this.stack.push(this.toScriptNumBuffer(-1));
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_1:
-                case opcode_js_1.Opcode.OP_2:
-                case opcode_js_1.Opcode.OP_3:
-                case opcode_js_1.Opcode.OP_4:
-                case opcode_js_1.Opcode.OP_5:
-                case opcode_js_1.Opcode.OP_6:
-                case opcode_js_1.Opcode.OP_7:
-                case opcode_js_1.Opcode.OP_8:
-                case opcode_js_1.Opcode.OP_9:
-                case opcode_js_1.Opcode.OP_10:
-                case opcode_js_1.Opcode.OP_11:
-                case opcode_js_1.Opcode.OP_12:
-                case opcode_js_1.Opcode.OP_13:
-                case opcode_js_1.Opcode.OP_14:
-                case opcode_js_1.Opcode.OP_15:
-                case opcode_js_1.Opcode.OP_16: {
-                    const value = opcodenum - opcode_js_1.Opcode.OP_1 + 1;
-                    this.stack.push(this.toScriptNumBuffer(value));
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_NOP:
-                case opcode_js_1.Opcode.OP_NOP1:
-                case opcode_js_1.Opcode.OP_NOP4:
-                case opcode_js_1.Opcode.OP_NOP5:
-                case opcode_js_1.Opcode.OP_NOP6:
-                case opcode_js_1.Opcode.OP_NOP7:
-                case opcode_js_1.Opcode.OP_NOP8:
-                case opcode_js_1.Opcode.OP_NOP9:
-                case opcode_js_1.Opcode.OP_NOP10: {
-                    if (this.flags & Interpreter.SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS) {
-                        this.errstr = 'SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS';
-                        return false;
-                    }
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_NOP2:
-                case opcode_js_1.Opcode.OP_CHECKLOCKTIMEVERIFY: {
-                    if (!(this.flags & Interpreter.SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY)) {
-                        if (this.flags & Interpreter.SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS) {
-                            this.errstr = 'SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS';
-                            return false;
-                        }
-                        break;
-                    }
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const fRequireMinimal = (this.flags & Interpreter.SCRIPT_VERIFY_MINIMALDATA) !== 0;
-                    const nLockTime = bn_js_1.BN.fromScriptNumBuffer(this.stack[this.stack.length - 1], fRequireMinimal, 5);
-                    if (nLockTime.lt(new bn_js_1.BN(0))) {
-                        this.errstr = 'SCRIPT_ERR_NEGATIVE_LOCKTIME';
-                        return false;
-                    }
-                    if (!this.checkLockTime(nLockTime)) {
-                        this.errstr = 'SCRIPT_ERR_UNSATISFIED_LOCKTIME';
-                        return false;
-                    }
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_NOP3:
-                case opcode_js_1.Opcode.OP_CHECKSEQUENCEVERIFY: {
-                    if (!(this.flags & Interpreter.SCRIPT_VERIFY_CHECKSEQUENCEVERIFY)) {
-                        if (this.flags & Interpreter.SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS) {
-                            this.errstr = 'SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS';
-                            return false;
-                        }
-                        break;
-                    }
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const fRequireMinimal = (this.flags & Interpreter.SCRIPT_VERIFY_MINIMALDATA) !== 0;
-                    const nSequence = bn_js_1.BN.fromScriptNumBuffer(this.stacktop(-1), fRequireMinimal, 5);
-                    if (nSequence.lt(new bn_js_1.BN(0))) {
-                        this.errstr = 'SCRIPT_ERR_NEGATIVE_LOCKTIME';
-                        return false;
-                    }
-                    if (!nSequence.and(Interpreter.SEQUENCE_LOCKTIME_DISABLE_FLAG).isZero()) {
-                        break;
-                    }
-                    if (!this.checkSequence(nSequence)) {
-                        this.errstr = 'SCRIPT_ERR_UNSATISFIED_LOCKTIME';
-                        return false;
-                    }
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_IF:
-                case opcode_js_1.Opcode.OP_NOTIF: {
-                    let fValue = false;
-                    if (fExec) {
-                        if (this.stack.length < 1) {
-                            this.errstr = 'SCRIPT_ERR_UNBALANCED_CONDITIONAL';
-                            return false;
-                        }
-                        const buf = this.stacktop(-1);
-                        if (this.flags & Interpreter.SCRIPT_VERIFY_MINIMALIF) {
-                            if (buf.length > 1) {
-                                this.errstr = 'SCRIPT_ERR_MINIMALIF';
-                                return false;
-                            }
-                            if (buf.length == 1 && buf[0] != 1) {
-                                this.errstr = 'SCRIPT_ERR_MINIMALIF';
-                                return false;
-                            }
-                        }
-                        fValue = Interpreter.castToBool(buf);
-                        if (opcodenum === opcode_js_1.Opcode.OP_NOTIF) {
-                            fValue = !fValue;
-                        }
-                        this.stack.pop();
-                    }
-                    this.vfExec.push(fValue);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_ELSE: {
-                    if (this.vfExec.length === 0) {
-                        this.errstr = 'SCRIPT_ERR_UNBALANCED_CONDITIONAL';
-                        return false;
-                    }
-                    this.vfExec[this.vfExec.length - 1] =
-                        !this.vfExec[this.vfExec.length - 1];
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_ENDIF: {
-                    if (this.vfExec.length === 0) {
-                        this.errstr = 'SCRIPT_ERR_UNBALANCED_CONDITIONAL';
-                        return false;
-                    }
-                    this.vfExec.pop();
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_VERIFY: {
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const buf = this.stacktop(-1);
-                    const fValue = Interpreter.castToBool(buf);
-                    if (fValue) {
-                        this.stack.pop();
-                    }
-                    else {
-                        this.errstr = 'SCRIPT_ERR_VERIFY';
-                        return false;
-                    }
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_RETURN:
-                    this.errstr = 'SCRIPT_ERR_OP_RETURN';
-                    return false;
-                case opcode_js_1.Opcode.OP_TOALTSTACK: {
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    this.altstack.push(this.stack.pop());
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_FROMALTSTACK: {
-                    if (this.altstack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_ALTSTACK_OPERATION';
-                        return false;
-                    }
-                    this.stack.push(this.altstack.pop());
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_2DROP: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    this.stack.pop();
-                    this.stack.pop();
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_2DUP: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const x1 = this.stack[this.stack.length - 2];
-                    const x2 = this.stack[this.stack.length - 1];
-                    this.stack.push(x1);
-                    this.stack.push(x2);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_3DUP: {
-                    if (this.stack.length < 3) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const x1 = this.stack[this.stack.length - 3];
-                    const x2 = this.stack[this.stack.length - 2];
-                    const x3 = this.stack[this.stack.length - 1];
-                    this.stack.push(x1);
-                    this.stack.push(x2);
-                    this.stack.push(x3);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_2OVER: {
-                    if (this.stack.length < 4) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const x1 = this.stack[this.stack.length - 4];
-                    const x2 = this.stack[this.stack.length - 3];
-                    this.stack.push(x1);
-                    this.stack.push(x2);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_2ROT: {
-                    if (this.stack.length < 6) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const x1 = this.stack.splice(this.stack.length - 6, 1)[0];
-                    const x2 = this.stack.splice(this.stack.length - 5, 1)[0];
-                    this.stack.push(x1);
-                    this.stack.push(x2);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_2SWAP: {
-                    if (this.stack.length < 4) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const x1 = this.stack[this.stack.length - 4];
-                    const x2 = this.stack[this.stack.length - 3];
-                    const x3 = this.stack[this.stack.length - 2];
-                    const x4 = this.stack[this.stack.length - 1];
-                    this.stack[this.stack.length - 4] = x3;
-                    this.stack[this.stack.length - 3] = x4;
-                    this.stack[this.stack.length - 2] = x1;
-                    this.stack[this.stack.length - 1] = x2;
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_DEPTH: {
-                    this.stack.push(this.toScriptNumBuffer(this.stack.length));
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_DROP: {
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    this.stack.pop();
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_DUP: {
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    this.stack.push(this.stack[this.stack.length - 1]);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_NIP: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    this.stack.splice(this.stack.length - 2, 1);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_OVER: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    this.stack.push(this.stack[this.stack.length - 2]);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_PICK:
-                case opcode_js_1.Opcode.OP_ROLL: {
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const n = this.fromScriptNumBuffer(this.stack[this.stack.length - 1]);
-                    this.stack.pop();
-                    if (n < 0n || n >= BigInt(this.stack.length)) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const val = this.stack[this.stack.length - 1 - Number(n)];
-                    if (opcodenum === opcode_js_1.Opcode.OP_ROLL) {
-                        this.stack.splice(this.stack.length - 1 - Number(n), 1);
-                    }
-                    this.stack.push(val);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_ROT: {
-                    if (this.stack.length < 3) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const x1 = this.stack[this.stack.length - 3];
-                    const x2 = this.stack[this.stack.length - 2];
-                    const x3 = this.stack[this.stack.length - 1];
-                    this.stack[this.stack.length - 3] = x2;
-                    this.stack[this.stack.length - 2] = x3;
-                    this.stack[this.stack.length - 1] = x1;
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_SWAP: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const x1 = this.stack[this.stack.length - 2];
-                    const x2 = this.stack[this.stack.length - 1];
-                    this.stack[this.stack.length - 2] = x2;
-                    this.stack[this.stack.length - 1] = x1;
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_TUCK: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const x1 = this.stack[this.stack.length - 2];
-                    const x2 = this.stack[this.stack.length - 1];
-                    this.stack.splice(this.stack.length - 2, 0, x2);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_SIZE: {
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const size = this.stack[this.stack.length - 1].length;
-                    this.stack.push(this.toScriptNumBuffer(size));
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_AND:
-                case opcode_js_1.Opcode.OP_OR:
-                case opcode_js_1.Opcode.OP_XOR: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const buf1 = this.stack.pop();
-                    const buf2 = this.stack.pop();
-                    if (buf1.length !== buf2.length) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_OPERAND_SIZE';
-                        return false;
-                    }
-                    const result = Buffer.alloc(buf1.length);
-                    for (let i = 0; i < buf1.length; i++) {
-                        switch (opcodenum) {
-                            case opcode_js_1.Opcode.OP_AND:
-                                result[i] = buf1[i] & buf2[i];
-                                break;
-                            case opcode_js_1.Opcode.OP_OR:
-                                result[i] = buf1[i] | buf2[i];
-                                break;
-                            case opcode_js_1.Opcode.OP_XOR:
-                                result[i] = buf1[i] ^ buf2[i];
-                                break;
-                        }
-                    }
-                    this.stack.push(result);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_EQUAL:
-                case opcode_js_1.Opcode.OP_EQUALVERIFY: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const buf1 = this.stacktop(-2);
-                    const buf2 = this.stacktop(-1);
-                    const fEqual = buf1.toString('hex') === buf2.toString('hex');
-                    this.stack.pop();
-                    this.stack.pop();
-                    this.stack.push(fEqual ? Interpreter.true : Interpreter.false);
-                    if (opcodenum === opcode_js_1.Opcode.OP_EQUALVERIFY) {
-                        if (fEqual) {
-                            this.stack.pop();
-                        }
-                        else {
-                            this.errstr = 'SCRIPT_ERR_EQUALVERIFY';
-                            return false;
-                        }
-                    }
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_1ADD: {
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const bn = this.fromScriptNumBuffer(this.stack[this.stack.length - 1]);
-                    this.stack[this.stack.length - 1] = this.toScriptNumBuffer(bn + 1n);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_1SUB: {
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const bn = this.fromScriptNumBuffer(this.stack[this.stack.length - 1]);
-                    this.stack[this.stack.length - 1] = this.toScriptNumBuffer(bn - 1n);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_NEGATE: {
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const bn = this.fromScriptNumBuffer(this.stack[this.stack.length - 1]);
-                    this.stack[this.stack.length - 1] = this.toScriptNumBuffer(-bn);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_ABS: {
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const bn = this.fromScriptNumBuffer(this.stack[this.stack.length - 1]);
-                    this.stack[this.stack.length - 1] = this.toScriptNumBuffer(bn < 0n ? -bn : bn);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_NOT: {
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const bn = this.fromScriptNumBuffer(this.stack[this.stack.length - 1]);
-                    this.stack[this.stack.length - 1] = this.toScriptNumBuffer(bn === 0n ? 1n : 0n);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_0NOTEQUAL: {
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const bn = this.fromScriptNumBuffer(this.stack[this.stack.length - 1]);
-                    this.stack[this.stack.length - 1] = this.toScriptNumBuffer(bn !== 0n ? 1n : 0n);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_ADD: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const bn1 = this.fromScriptNumBuffer(this.stack.pop());
-                    const bn2 = this.fromScriptNumBuffer(this.stack.pop());
-                    this.stack.push(this.toScriptNumBuffer(bn1 + bn2));
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_SUB: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const bn1 = this.fromScriptNumBuffer(this.stack.pop());
-                    const bn2 = this.fromScriptNumBuffer(this.stack.pop());
-                    this.stack.push(this.toScriptNumBuffer(bn2 - bn1));
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_BOOLAND: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const bn1 = this.fromScriptNumBuffer(this.stack.pop());
-                    const bn2 = this.fromScriptNumBuffer(this.stack.pop());
-                    const result = bn1 !== 0n && bn2 !== 0n ? 1n : 0n;
-                    this.stack.push(this.toScriptNumBuffer(result));
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_BOOLOR: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const bn1 = this.fromScriptNumBuffer(this.stack.pop());
-                    const bn2 = this.fromScriptNumBuffer(this.stack.pop());
-                    const result = bn1 !== 0n || bn2 !== 0n ? 1n : 0n;
-                    this.stack.push(this.toScriptNumBuffer(result));
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_LESSTHAN: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const bn1 = this.fromScriptNumBuffer(this.stack.pop());
-                    const bn2 = this.fromScriptNumBuffer(this.stack.pop());
-                    const result = bn2 < bn1 ? 1n : 0n;
-                    this.stack.push(this.toScriptNumBuffer(result));
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_GREATERTHAN: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const bn1 = this.fromScriptNumBuffer(this.stack.pop());
-                    const bn2 = this.fromScriptNumBuffer(this.stack.pop());
-                    const result = bn2 > bn1 ? 1n : 0n;
-                    this.stack.push(this.toScriptNumBuffer(result));
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_LESSTHANOREQUAL: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const bn1 = this.fromScriptNumBuffer(this.stack.pop());
-                    const bn2 = this.fromScriptNumBuffer(this.stack.pop());
-                    const result = bn2 <= bn1 ? 1n : 0n;
-                    this.stack.push(this.toScriptNumBuffer(result));
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_GREATERTHANOREQUAL: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const bn1 = this.fromScriptNumBuffer(this.stack.pop());
-                    const bn2 = this.fromScriptNumBuffer(this.stack.pop());
-                    const result = bn2 >= bn1 ? 1n : 0n;
-                    this.stack.push(this.toScriptNumBuffer(result));
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_MIN: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const bn1 = this.fromScriptNumBuffer(this.stack.pop());
-                    const bn2 = this.fromScriptNumBuffer(this.stack.pop());
-                    const result = bn1 < bn2 ? bn1 : bn2;
-                    this.stack.push(this.toScriptNumBuffer(result));
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_MAX: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const bn1 = this.fromScriptNumBuffer(this.stack.pop());
-                    const bn2 = this.fromScriptNumBuffer(this.stack.pop());
-                    const result = bn1 > bn2 ? bn1 : bn2;
-                    this.stack.push(this.toScriptNumBuffer(result));
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_WITHIN: {
-                    if (this.stack.length < 3) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const bn1 = this.fromScriptNumBuffer(this.stack.pop());
-                    const bn2 = this.fromScriptNumBuffer(this.stack.pop());
-                    const bn3 = this.fromScriptNumBuffer(this.stack.pop());
-                    const result = bn3 >= bn2 && bn3 < bn1 ? 1n : 0n;
-                    this.stack.push(this.toScriptNumBuffer(result));
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_RIPEMD160: {
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const buf = this.stack.pop();
-                    this.stack.push(hash_js_1.Hash.ripemd160(buf));
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_SHA256: {
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const buf = this.stack.pop();
-                    this.stack.push(hash_js_1.Hash.sha256(buf));
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_HASH160: {
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const buf = this.stack.pop();
-                    this.stack.push(hash_js_1.Hash.sha256ripemd160(buf));
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_HASH256: {
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const buf = this.stack.pop();
-                    this.stack.push(hash_js_1.Hash.sha256sha256(buf));
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_CODESEPARATOR: {
-                    this.pbegincodehash = this.pc;
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_CHECKDATASIG:
-                case opcode_js_1.Opcode.OP_CHECKDATASIGVERIFY: {
-                    if (this.stack.length < 3) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const bufSig = this.stacktop(-3);
-                    const bufMessage = this.stacktop(-2);
-                    const bufPubkey = this.stacktop(-1);
-                    if (!this.checkDataSignatureEncoding(bufSig) ||
-                        !this.checkPubkeyEncoding(bufPubkey)) {
-                        return false;
-                    }
-                    let fSuccess = false;
-                    try {
-                        const sig = signature_js_1.Signature.fromDataFormat(bufSig);
-                        const pubkey = new publickey_js_1.PublicKey(bufPubkey);
-                        const bufHash = hash_js_1.Hash.sha256(bufMessage);
-                        if (!sig.isSchnorr) {
-                            fSuccess = ecdsa_js_1.ECDSA.verify(bufHash, sig, pubkey, 'big');
-                        }
-                        else {
-                            fSuccess = schnorr_js_1.Schnorr.verify(bufHash, sig, pubkey, 'big');
-                        }
-                    }
-                    catch (e) {
-                        fSuccess = false;
-                    }
-                    if (!fSuccess &&
-                        this.flags & Interpreter.SCRIPT_VERIFY_NULLFAIL &&
-                        bufSig.length) {
-                        this.errstr = 'SCRIPT_ERR_NULLFAIL';
-                        return false;
-                    }
-                    this.stack.pop();
-                    this.stack.pop();
-                    this.stack.pop();
-                    this.stack.push(fSuccess ? Interpreter.true : Interpreter.false);
-                    if (opcodenum === opcode_js_1.Opcode.OP_CHECKDATASIGVERIFY) {
-                        if (fSuccess) {
-                            this.stack.pop();
-                        }
-                        else {
-                            this.errstr = 'SCRIPT_ERR_CHECKDATASIGVERIFY';
-                            return false;
-                        }
-                    }
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_REVERSEBYTES: {
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const buf = this.stacktop(-1);
-                    const reversedBuf = Buffer.from(buf).reverse();
-                    this.stack.pop();
-                    this.stack.push(reversedBuf);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_CHECKSIG: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const sigBuf = this.stack[this.stack.length - 2];
-                    const pubkeyBuf = this.stack[this.stack.length - 1];
-                    if (!this.checkTxSignatureEncoding(sigBuf) ||
-                        !this.checkPubkeyEncoding(pubkeyBuf)) {
-                        return false;
-                    }
-                    const subscript = new script_js_1.Script();
-                    subscript.chunks = this.script.chunks.slice(this.pbegincodehash);
-                    const tmpScript = new script_js_1.Script().add(sigBuf);
-                    subscript.findAndDelete(tmpScript);
-                    let fSuccess = false;
-                    try {
-                        const signature = signature_js_1.Signature.fromTxFormat(sigBuf);
-                        const pubkey = new publickey_js_1.PublicKey(pubkeyBuf);
-                        if (this.tx &&
-                            this.nin !== undefined &&
-                            this.satoshisBN !== undefined) {
-                            if (!signature.isSchnorr) {
-                                fSuccess = this.tx.verifySignature(signature, pubkey, this.nin, subscript, new bn_js_1.BN(this.satoshisBN.toString()), this.flags);
-                            }
-                            else {
-                                fSuccess = this.tx.verifySignature(signature, pubkey, this.nin, subscript, new bn_js_1.BN(this.satoshisBN.toString()), this.flags, 'schnorr');
-                            }
-                        }
-                    }
-                    catch (e) {
-                        fSuccess = false;
-                    }
-                    if (!fSuccess &&
-                        this.flags & Interpreter.SCRIPT_VERIFY_NULLFAIL &&
-                        sigBuf.length) {
-                        this.errstr = 'SCRIPT_ERR_NULLFAIL';
-                        return false;
-                    }
-                    this.stack.pop();
-                    this.stack.pop();
-                    this.stack.push(fSuccess ? Interpreter.true : Interpreter.false);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_CHECKSIGVERIFY: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const sigBuf2 = this.stack[this.stack.length - 2];
-                    const pubkeyBuf2 = this.stack[this.stack.length - 1];
-                    if (!this.checkTxSignatureEncoding(sigBuf2) ||
-                        !this.checkPubkeyEncoding(pubkeyBuf2)) {
-                        return false;
-                    }
-                    const subscript2 = new script_js_1.Script();
-                    subscript2.chunks = this.script.chunks.slice(this.pbegincodehash);
-                    const tmpScript2 = new script_js_1.Script().add(sigBuf2);
-                    subscript2.findAndDelete(tmpScript2);
-                    let fSuccess2 = false;
-                    try {
-                        const signature = signature_js_1.Signature.fromTxFormat(sigBuf2);
-                        const pubkey = new publickey_js_1.PublicKey(pubkeyBuf2);
-                        if (this.tx &&
-                            this.nin !== undefined &&
-                            this.satoshisBN !== undefined) {
-                            if (!signature.isSchnorr) {
-                                fSuccess2 = this.tx.verifySignature(signature, pubkey, this.nin, subscript2, new bn_js_1.BN(this.satoshisBN.toString()), this.flags);
-                            }
-                            else {
-                                fSuccess2 = this.tx.verifySignature(signature, pubkey, this.nin, subscript2, new bn_js_1.BN(this.satoshisBN.toString()), this.flags, 'schnorr');
-                            }
-                        }
-                    }
-                    catch (e) {
-                        fSuccess2 = false;
-                    }
-                    if (!fSuccess2 &&
-                        this.flags & Interpreter.SCRIPT_VERIFY_NULLFAIL &&
-                        sigBuf2.length) {
-                        this.errstr = 'SCRIPT_ERR_NULLFAIL';
-                        return false;
-                    }
-                    this.stack.pop();
-                    this.stack.pop();
-                    if (fSuccess2) {
-                    }
-                    else {
-                        this.errstr = 'SCRIPT_ERR_CHECKSIGVERIFY';
-                        return false;
-                    }
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_CHECKMULTISIG:
-                case opcode_js_1.Opcode.OP_CHECKMULTISIGVERIFY: {
-                    const fRequireMinimal = (this.flags & Interpreter.SCRIPT_VERIFY_MINIMALDATA) !== 0;
-                    let i = 1;
-                    const idxTopKey = i + 1;
-                    if (this.stack.length < i) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const nKeysCountBN = bn_js_1.BN.fromScriptNumBuffer(this.stacktop(-i), fRequireMinimal);
-                    let nKeysCount = nKeysCountBN.toNumber();
-                    const idxSigCount = idxTopKey + nKeysCount;
-                    if (nKeysCount < 0 || nKeysCount > 20) {
-                        this.errstr = 'SCRIPT_ERR_PUBKEY_COUNT';
-                        return false;
-                    }
-                    this.nOpCount += nKeysCount;
-                    if (this.nOpCount > 201) {
-                        this.errstr = 'SCRIPT_ERR_OP_COUNT';
-                        return false;
-                    }
-                    let ikey = ++i;
-                    const idxTopSig = idxSigCount + 1;
-                    i += nKeysCount;
-                    let ikey2 = nKeysCount + 2;
-                    if (this.stack.length < i) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const nSigsCountBN = bn_js_1.BN.fromScriptNumBuffer(this.stacktop(-idxSigCount), fRequireMinimal);
-                    let nSigsCount = nSigsCountBN.toNumber();
-                    const idxDummy = idxTopSig + nSigsCount;
-                    if (nSigsCount < 0 || nSigsCount > nKeysCount) {
-                        this.errstr = 'SCRIPT_ERR_SIG_COUNT';
-                        return false;
-                    }
-                    let isig = ++i;
-                    i += nSigsCount;
-                    if (this.stack.length < idxDummy) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const subscript = new script_js_1.Script();
-                    subscript.chunks = this.script.chunks.slice(this.pbegincodehash);
-                    let fSuccess = true;
-                    if (this.flags & Interpreter.SCRIPT_ENABLE_SCHNORR_MULTISIG &&
-                        this.stacktop(-idxDummy).length !== 0) {
-                        const dummy = this.stacktop(-idxDummy);
-                        const bitfieldObj = this.decodeBitfield(dummy, nKeysCount);
-                        if (!bitfieldObj.result) {
-                            fSuccess = false;
-                        }
-                        const nSigs8bit = new Uint8Array([nSigsCount]);
-                        const nSigs32 = Uint32Array.from(nSigs8bit);
-                        if (this.countBits(bitfieldObj.bitfield) !== nSigs32[0]) {
-                            this.errstr = 'INVALID_BIT_COUNT';
-                            fSuccess = false;
-                        }
-                        const bottomKey = idxTopKey + nKeysCount - 1;
-                        const bottomSig = idxTopSig + nSigsCount - 1;
-                        let iKey = 0;
-                        for (let iSig = 0; iSig < nSigsCount; iSig++, iKey++) {
-                            if (bitfieldObj.bitfield >> iKey === 0) {
-                                this.errstr = 'INVALID_BIT_RANGE';
-                                fSuccess = false;
-                            }
-                            while (((bitfieldObj.bitfield >> iKey) & 0x01) == 0) {
-                                if (iKey >= nKeysCount) {
-                                    this.errstr = 'wrong';
-                                    fSuccess = false;
-                                    break;
-                                }
-                                iKey++;
-                            }
-                            if (iKey >= nKeysCount) {
-                                this.errstr = 'PUBKEY_COUNT';
-                                fSuccess = false;
-                            }
-                            const bufsig = this.stacktop(-bottomSig + iSig);
-                            const bufPubkey = this.stacktop(-bottomKey + iKey);
-                            if (!this.checkRawSignatureEncoding(bufsig) ||
-                                !this.checkPubkeyEncoding(bufPubkey)) {
-                                fSuccess = false;
-                            }
-                            try {
-                                const sig = signature_js_1.Signature.fromTxFormat(bufsig);
-                                const pubkey = new publickey_js_1.PublicKey(bufPubkey);
-                                const fOk = this.tx?.verifySignature(sig, pubkey, this.nin, subscript, new bn_js_1.BN(this.satoshisBN.toString()), this.flags, 'schnorr') || false;
-                                if (!fOk) {
-                                    this.errstr = 'SIG_NULLFAIL';
-                                    fSuccess = false;
-                                }
-                            }
-                            catch (e) {
-                                fSuccess = false;
-                            }
-                        }
-                        if (bitfieldObj.bitfield >> iKey != 0) {
-                            this.errstr = 'INVALID_BIT_COUNT';
-                            fSuccess = false;
-                        }
-                    }
-                    else {
-                        for (let k = 0; k < nSigsCount; k++) {
-                            const bufSig = this.stacktop(-isig - k);
-                            subscript.findAndDelete(new script_js_1.Script().add(bufSig));
-                        }
-                        while (fSuccess && nSigsCount > 0) {
-                            const bufSig = this.stacktop(-isig);
-                            const bufPubkey = this.stacktop(-ikey);
-                            if (!this.checkTxSignatureEncoding(bufSig) ||
-                                !this.checkPubkeyEncoding(bufPubkey)) {
-                                return false;
-                            }
-                            let fOk = false;
-                            try {
-                                const sig = signature_js_1.Signature.fromTxFormat(bufSig);
-                                const pubkey = new publickey_js_1.PublicKey(bufPubkey);
-                                fOk =
-                                    this.tx?.verifySignature(sig, pubkey, this.nin, subscript, new bn_js_1.BN(this.satoshisBN.toString()), this.flags) || false;
-                            }
-                            catch (e) {
-                                fOk = false;
-                            }
-                            if (fOk) {
-                                isig++;
-                                nSigsCount--;
-                            }
-                            ikey++;
-                            nKeysCount--;
-                            if (nSigsCount > nKeysCount) {
-                                fSuccess = false;
-                            }
-                        }
-                    }
-                    while (i-- > 1) {
-                        if (!fSuccess &&
-                            this.flags & Interpreter.SCRIPT_VERIFY_NULLFAIL &&
-                            !ikey2 &&
-                            this.stacktop(-1).length) {
-                            this.errstr = 'SCRIPT_ERR_NULLFAIL';
-                            return false;
-                        }
-                        if (ikey2 > 0) {
-                            ikey2--;
-                        }
-                        this.stack.pop();
-                    }
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    if (this.flags & Interpreter.SCRIPT_VERIFY_NULLDUMMY &&
-                        this.stacktop(-1).length) {
-                        this.errstr = 'SCRIPT_ERR_SIG_NULLDUMMY';
-                        return false;
-                    }
-                    this.stack.pop();
-                    this.stack.push(fSuccess ? Interpreter.true : Interpreter.false);
-                    if (opcodenum === opcode_js_1.Opcode.OP_CHECKMULTISIGVERIFY) {
-                        if (fSuccess) {
-                            this.stack.pop();
-                        }
-                        else {
-                            this.errstr = 'SCRIPT_ERR_CHECKMULTISIGVERIFY';
-                            return false;
-                        }
-                    }
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_CAT: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const buf1 = this.stacktop(-2);
-                    const buf2 = this.stacktop(-1);
-                    if (buf1.length + buf2.length > Interpreter.MAX_SCRIPT_ELEMENT_SIZE) {
-                        this.errstr = 'SCRIPT_ERR_PUSH_SIZE';
-                        return false;
-                    }
-                    this.stack[this.stack.length - 2] = Buffer.concat([buf1, buf2]);
-                    this.stack.pop();
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_SPLIT: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const fRequireMinimal = (this.flags & Interpreter.SCRIPT_VERIFY_MINIMALDATA) !== 0;
-                    const buf1 = this.stacktop(-2);
-                    const position = bn_js_1.BN.fromScriptNumBuffer(this.stacktop(-1), fRequireMinimal).toNumber();
-                    if (position < 0 || position > buf1.length) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_SPLIT_RANGE';
-                        return false;
-                    }
-                    const n1 = Buffer.from(buf1);
-                    this.stack[this.stack.length - 2] = n1.subarray(0, position);
-                    this.stack[this.stack.length - 1] = n1.subarray(position);
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_NUM2BIN: {
-                    if (this.stack.length < 2) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const fRequireMinimal = (this.flags & Interpreter.SCRIPT_VERIFY_MINIMALDATA) !== 0;
-                    const size = bn_js_1.BN.fromScriptNumBuffer(this.stacktop(-1), fRequireMinimal).toNumber();
-                    if (size > Interpreter.MAX_SCRIPT_ELEMENT_SIZE) {
-                        this.errstr = 'SCRIPT_ERR_PUSH_SIZE';
-                        return false;
-                    }
-                    this.stack.pop();
-                    let rawnum = this.stacktop(-1);
-                    rawnum = Interpreter._minimallyEncode(rawnum);
-                    if (rawnum.length > size) {
-                        this.errstr = 'SCRIPT_ERR_IMPOSSIBLE_ENCODING';
-                        return false;
-                    }
-                    if (rawnum.length == size) {
-                        this.stack[this.stack.length - 1] = rawnum;
-                        break;
-                    }
-                    let signbit = 0x00;
-                    if (rawnum.length > 0) {
-                        signbit = rawnum[rawnum.length - 1] & 0x80;
-                        rawnum[rawnum.length - 1] &= 0x7f;
-                    }
-                    const num = Buffer.alloc(size);
-                    rawnum.copy(num, 0);
-                    let l = rawnum.length - 1;
-                    while (l++ < size - 2) {
-                        num[l] = 0x00;
-                    }
-                    num[l] = signbit;
-                    this.stack[this.stack.length - 1] = num;
-                    break;
-                }
-                case opcode_js_1.Opcode.OP_BIN2NUM: {
-                    if (this.stack.length < 1) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION';
-                        return false;
-                    }
-                    const buf1 = this.stacktop(-1);
-                    const buf2 = Interpreter._minimallyEncode(buf1);
-                    this.stack[this.stack.length - 1] = buf2;
-                    if (!Interpreter._isMinimallyEncoded(buf2)) {
-                        this.errstr = 'SCRIPT_ERR_INVALID_NUMBER_RANGE';
-                        return false;
-                    }
-                    break;
-                }
-                default:
-                    this.errstr = 'SCRIPT_ERR_BAD_OPCODE';
-                    return false;
-            }
-        }
-        return true;
-    }
-    decodeBitfield(dummy, size) {
-        if (size > 32) {
-            this.errstr = 'INVALID_BITFIELD_SIZE';
-            return { result: false };
-        }
-        const bitfieldSize = Math.floor((size + 7) / 8);
-        const dummyBitlength = dummy.length;
-        if (dummyBitlength !== bitfieldSize) {
-            this.errstr = 'INVALID_BITFIELD_SIZE';
-            return { result: false };
-        }
-        let bitfield = 0;
-        const dummyAs32Bit = Uint32Array.from(dummy);
-        for (let i = 0; i < bitfieldSize; i++) {
-            bitfield = bitfield | (dummyAs32Bit[i] << (8 * i));
-        }
-        const mask = (0x01 << size) - 1;
-        if ((bitfield & mask) != bitfield) {
-            this.errstr = 'INVALID_BIT_RANGE';
-            return { result: false };
-        }
-        return { result: true, bitfield: bitfield };
-    }
-    countBits(v) {
-        v = v - ((v >> 1) & 0x55555555);
-        v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
-        return (((v + (v >> 4)) & 0xf0f0f0f) * 0x1010101) >> 24;
-    }
-    stacktop(i) {
-        return this.stack[this.stack.length + i];
-    }
-    isOpcodeDisabled(opcode) {
-        switch (opcode) {
-            case 80:
-            case 101:
-            case 102:
-            case 115:
-            case opcode_js_1.Opcode.OP_INVERT:
-            case 137:
-            case 138:
-            case opcode_js_1.Opcode.OP_2MUL:
-            case opcode_js_1.Opcode.OP_2DIV:
-            case opcode_js_1.Opcode.OP_MUL:
-            case 156:
-            case 157:
-            case 158:
-            case 167:
-            case opcode_js_1.Opcode.OP_LSHIFT:
-            case opcode_js_1.Opcode.OP_RSHIFT:
-                return true;
-            case opcode_js_1.Opcode.OP_DIV:
-            case opcode_js_1.Opcode.OP_MOD:
-            case opcode_js_1.Opcode.OP_SPLIT:
-            case opcode_js_1.Opcode.OP_CAT:
-            case opcode_js_1.Opcode.OP_AND:
-            case opcode_js_1.Opcode.OP_OR:
-            case opcode_js_1.Opcode.OP_XOR:
-            case opcode_js_1.Opcode.OP_BIN2NUM:
-            case opcode_js_1.Opcode.OP_NUM2BIN:
-                return false;
-            default:
-                if (opcode >= 189) {
-                    return true;
-                }
-                return false;
-        }
-    }
-    checkLockTime(nLockTime) {
-        if (!this.tx || this.nin === undefined) {
-            return false;
-        }
-        if (!((this.tx.nLockTime < Interpreter.LOCKTIME_THRESHOLD &&
-            nLockTime.lt(Interpreter.LOCKTIME_THRESHOLD_BN)) ||
-            (this.tx.nLockTime >= Interpreter.LOCKTIME_THRESHOLD &&
-                nLockTime.gte(Interpreter.LOCKTIME_THRESHOLD_BN)))) {
-            return false;
-        }
-        if (nLockTime.gt(new bn_js_1.BN(this.tx.nLockTime))) {
-            return false;
-        }
-        if (!this.tx.inputs[this.nin].isFinal()) {
-            return false;
-        }
-        return true;
-    }
-    checkSequence(nSequence) {
-        if (!this.tx || this.nin === undefined) {
-            return false;
-        }
-        const txToSequence = this.tx.inputs[this.nin].sequenceNumber;
-        if (this.tx.version < 2) {
-            return false;
-        }
-        if (txToSequence & Interpreter.SEQUENCE_LOCKTIME_DISABLE_FLAG) {
-            return false;
-        }
-        const nLockTimeMask = Interpreter.SEQUENCE_LOCKTIME_TYPE_FLAG |
-            Interpreter.SEQUENCE_LOCKTIME_MASK;
-        const txToSequenceMasked = new bn_js_1.BN(txToSequence & nLockTimeMask);
-        const nSequenceMasked = nSequence.and(nLockTimeMask);
-        const SEQUENCE_LOCKTIME_TYPE_FLAG_BN = new bn_js_1.BN(Interpreter.SEQUENCE_LOCKTIME_TYPE_FLAG);
-        if (!((txToSequenceMasked.lt(SEQUENCE_LOCKTIME_TYPE_FLAG_BN) &&
-            nSequenceMasked.lt(SEQUENCE_LOCKTIME_TYPE_FLAG_BN)) ||
-            (txToSequenceMasked.gte(SEQUENCE_LOCKTIME_TYPE_FLAG_BN) &&
-                nSequenceMasked.gte(SEQUENCE_LOCKTIME_TYPE_FLAG_BN)))) {
-            return false;
-        }
-        if (nSequenceMasked.gt(txToSequenceMasked)) {
-            return false;
-        }
-        return true;
-    }
-    static castToBool(buf) {
-        for (let i = 0; i < buf.length; i++) {
-            if (buf[i] !== 0) {
-                if (i === buf.length - 1 && buf[i] === 0x80) {
-                    return false;
-                }
-                return true;
-            }
-        }
-        return false;
-    }
-    static isSchnorrSig(buf) {
-        return (buf.length === 64 || buf.length === 65) && buf[0] !== 0x30;
-    }
-    _verifyScriptType(scriptPubkey) {
-        const buf = scriptPubkey.toBuffer();
-        if (buf.length < 2) {
-            this.errstr = 'SCRIPT_ERR_SCRIPTTYPE_MALFORMED_SCRIPT';
-            return false;
-        }
-        const scriptType = buf[1];
-        switch (scriptType) {
-            case taproot_js_1.TAPROOT_SCRIPTTYPE: {
-                const result = (0, taproot_js_1.verifyTaprootSpend)(scriptPubkey, this.stack, this.flags);
-                if (!result.success) {
-                    this.errstr = result.error || 'SCRIPT_ERR_UNKNOWN';
-                    return false;
-                }
-                if (result.stack) {
-                    this.stack = result.stack;
-                }
-                if (result.scriptToExecute) {
-                    const prevScript = this.script;
-                    const prevPc = this.pc;
-                    const prevPbegincodehash = this.pbegincodehash;
-                    this.script = result.scriptToExecute;
-                    this.pc = 0;
-                    this.pbegincodehash = 0;
-                    const evalResult = this.evaluate();
-                    this.script = prevScript;
-                    this.pc = prevPc;
-                    this.pbegincodehash = prevPbegincodehash;
-                    if (!evalResult) {
-                        return false;
-                    }
-                    if (this.stack.length === 0) {
-                        this.errstr = 'SCRIPT_ERR_EVAL_FALSE_NO_RESULT';
-                        return false;
-                    }
-                    const finalBuf = this.stack[this.stack.length - 1];
-                    if (!Interpreter.castToBool(finalBuf)) {
-                        this.errstr = 'SCRIPT_ERR_EVAL_FALSE_IN_STACK';
-                        return false;
-                    }
-                }
-                else {
-                    const scriptBuf = scriptPubkey.toBuffer();
-                    const vchPubkey = scriptBuf.subarray(taproot_js_1.TAPROOT_INTRO_SIZE, taproot_js_1.TAPROOT_SIZE_WITHOUT_STATE);
-                    const vchSig = this.stack[this.stack.length - 1];
-                    const sigFlags = this.flags | Interpreter.SCRIPT_TAPROOT_KEY_SPEND_PATH;
-                    if (!this.checkTxSignatureEncoding(vchSig) ||
-                        !this.checkPubkeyEncoding(vchPubkey)) {
-                        return false;
-                    }
-                    if (vchSig.length === 0) {
-                        this.errstr = 'SCRIPT_ERR_TAPROOT_VERIFY_SIGNATURE_FAILED';
-                        return false;
-                    }
-                    const sig = signature_js_1.Signature.fromTxFormat(vchSig);
-                    const pubkey = new publickey_js_1.PublicKey(vchPubkey);
-                    if (!sig.isSchnorr) {
-                        this.errstr = 'SCRIPT_ERR_TAPROOT_KEY_SPEND_SIGNATURE_NOT_SCHNORR';
-                        return false;
-                    }
-                    try {
-                        const isValid = this.tx?.verifySignature(sig, pubkey, this.nin, scriptPubkey, new bn_js_1.BN(this.satoshisBN.toString()), sigFlags, 'schnorr');
-                        if (!isValid) {
-                            this.errstr = 'SCRIPT_ERR_TAPROOT_VERIFY_SIGNATURE_FAILED';
-                            return false;
-                        }
-                    }
-                    catch (e) {
-                        this.errstr = 'SCRIPT_ERR_TAPROOT_VERIFY_SIGNATURE_FAILED';
-                        return false;
-                    }
-                }
-                return true;
-            }
-            default:
-                this.errstr = 'SCRIPT_ERR_SCRIPTTYPE_INVALID_TYPE';
-                return false;
-        }
-    }
-    static _isMinimallyEncoded(buf, nMaxNumSize) {
-        nMaxNumSize = nMaxNumSize || Interpreter.MAXIMUM_ELEMENT_SIZE;
-        if (buf.length > nMaxNumSize) {
-            return false;
-        }
-        if (buf.length > 0) {
-            if ((buf[buf.length - 1] & 0x7f) === 0) {
-                if (buf.length <= 1 || (buf[buf.length - 2] & 0x80) === 0) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-    static _minimallyEncode(buf) {
-        if (buf.length === 0) {
-            return buf;
-        }
-        const last = buf[buf.length - 1];
-        if (last & 0x7f) {
-            return buf;
-        }
-        if (buf.length === 1) {
-            return Buffer.from('');
-        }
-        if (buf[buf.length - 2] & 0x80) {
-            return buf;
-        }
-        for (let i = buf.length - 1; i > 0; i--) {
-            if (buf[i - 1] !== 0) {
-                if (buf[i - 1] & 0x80) {
-                    const result = Buffer.alloc(i + 1);
-                    buf.copy(result, 0, 0, i);
-                    result[i] = last;
-                    return result;
-                }
-                else {
-                    const result = Buffer.alloc(i);
-                    buf.copy(result, 0, 0, i);
-                    result[i - 1] |= last;
-                    return result;
-                }
-            }
-        }
-        return Buffer.from('');
-    }
-}
-exports.Interpreter = Interpreter;