xpi-ts 0.2.13 → 0.2.15

package/dist/cjs/lib/bitcore/transaction/transaction.js

@@ -1,23 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Transaction = void 0;
-const preconditions_js_1 = require("../util/preconditions.js");
-const js_js_1 = require("../util/js.js");
-const bufferreader_js_1 = require("../encoding/bufferreader.js");
-const bufferwriter_js_1 = require("../encoding/bufferwriter.js");
-const hash_js_1 = require("../crypto/hash.js");
-const signature_js_1 = require("../crypto/signature.js");
-const sighash_js_1 = require("./sighash.js");
-const errors_js_1 = require("../errors.js");
-const address_js_1 = require("../address.js");
-const unspentoutput_js_1 = require("./unspentoutput.js");
-const input_js_1 = require("./input.js");
-const output_js_1 = require("./output.js");
-const script_js_1 = require("../script.js");
-const privatekey_js_1 = require("../privatekey.js");
-const bn_js_1 = require("../crypto/bn.js");
-const sighash_js_2 = require("./sighash.js");
-const interpreter_js_1 = require("../script/interpreter.js");
+const preconditions_1 = require("../util/preconditions");
+const js_1 = require("../util/js");
+const bufferreader_1 = require("../encoding/bufferreader");
+const bufferwriter_1 = require("../encoding/bufferwriter");
+const hash_1 = require("../crypto/hash");
+const signature_1 = require("../crypto/signature");
+const sighash_1 = require("./sighash");
+const errors_1 = require("../errors");
+const address_1 = require("../address");
+const unspentoutput_1 = require("./unspentoutput");
+const input_1 = require("./input");
+const output_1 = require("./output");
+const script_1 = require("../script");
+const privatekey_1 = require("../privatekey");
+const bn_1 = require("../crypto/bn");
+const sighash_2 = require("./sighash");
+const interpreter_1 = require("../script/interpreter");
+const util_1 = require("../util");
 const CURRENT_VERSION = 2;
 const DEFAULT_NLOCKTIME = 0;
 const MAX_BLOCK_SIZE = 32_000_000;
@@ -29,7 +30,7 @@ const NLOCKTIME_MAX_VALUE = 4294967295;
 const FEE_PER_KB = 1_000;
 const CHANGE_OUTPUT_MAX_SIZE = 20 + 4 + 34 + 4;
 const MAXIMUM_EXTRA_SIZE = 4 + 9 + 9 + 4;
-const NULL_HASH = Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
+const NULL_HASH = util_1.BufferUtil.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
 class Transaction {
     static DUST_AMOUNT = DUST_AMOUNT;
     static FEE_SECURITY_MARGIN = FEE_SECURITY_MARGIN;
@@ -62,10 +63,10 @@ class Transaction {
         if (serialized instanceof Transaction) {
             return Transaction.shallowCopy(serialized);
         }
-        else if (typeof serialized === 'string' && js_js_1.JSUtil.isHexa(serialized)) {
+        else if (typeof serialized === 'string' && js_1.JSUtil.isHexa(serialized)) {
             this.fromString(serialized);
         }
-        else if (Buffer.isBuffer(serialized)) {
+        else if (util_1.BufferUtil.isBuffer(serialized)) {
             this.fromBuffer(serialized);
         }
         else if (serialized && typeof serialized === 'object') {
@@ -97,22 +98,28 @@ class Transaction {
     get hash() {
         if (!this._hash) {
             const hashBuffer = this._getHash();
-            const reader = new bufferreader_js_1.BufferReader(hashBuffer);
+            const reader = new bufferreader_1.BufferReader(hashBuffer);
             this._hash = reader.readReverse(32).toString('hex');
         }
         return this._hash;
     }
+    get hashBuffer() {
+        return this._getHash();
+    }
     get id() {
         return this.txid;
     }
     get txid() {
         if (!this._txid) {
             const txidBuffer = this._getTxid();
-            const reader = new bufferreader_js_1.BufferReader(txidBuffer);
+            const reader = new bufferreader_1.BufferReader(txidBuffer);
             this._txid = reader.readReverse(32).toString('hex');
         }
         return this._txid;
     }
+    get txidBuffer() {
+        return this._getTxid();
+    }
     get inputAmount() {
         return this._getInputAmount();
     }
@@ -138,10 +145,10 @@ class Transaction {
         this._version = version;
     }
     _getHash() {
-        return hash_js_1.Hash.sha256sha256(this.toBuffer());
+        return hash_1.Hash.sha256sha256(this.toBuffer());
     }
     _getTxid() {
-        const writer = new bufferwriter_js_1.BufferWriter();
+        const writer = new bufferwriter_1.BufferWriter();
         writer.writeInt32LE(this.version);
         const inputHashes = this._getTxInputHashes();
         const outputHashes = this._getTxOutputHashes();
@@ -152,7 +159,7 @@ class Transaction {
         writer.write(outputMerkleRootAndHeight.root);
         writer.writeUInt8(outputMerkleRootAndHeight.height);
         writer.writeUInt32LE(this.nLockTime);
-        return hash_js_1.Hash.sha256sha256(writer.toBuffer());
+        return hash_1.Hash.sha256sha256(writer.toBuffer());
     }
     _getTxInputHashes() {
         const hashes = [];
@@ -161,11 +168,11 @@ class Transaction {
         }
         for (let i = 0; i < this.inputs.length; i++) {
             const input = this.inputs[i];
-            const writer = new bufferwriter_js_1.BufferWriter();
+            const writer = new bufferwriter_1.BufferWriter();
             writer.writeReverse(input.prevTxId);
             writer.writeUInt32LE(input.outputIndex);
             writer.writeUInt32LE(Number(input.sequenceNumber));
-            const hash = hash_js_1.Hash.sha256sha256(writer.toBuffer());
+            const hash = hash_1.Hash.sha256sha256(writer.toBuffer());
             hashes.push(hash);
         }
         return hashes;
@@ -177,10 +184,10 @@ class Transaction {
         }
         for (let i = 0; i < this.outputs.length; i++) {
             const output = this.outputs[i];
-            const writer = new bufferwriter_js_1.BufferWriter();
-            writer.writeUInt64LEBN(new bn_js_1.BN(output.satoshis));
+            const writer = new bufferwriter_1.BufferWriter();
+            writer.writeUInt64LEBN(new bn_1.BN(output.satoshis));
             writer.writeVarLengthBuffer(output.scriptBuffer);
-            const hash = hash_js_1.Hash.sha256sha256(writer.toBuffer());
+            const hash = hash_1.Hash.sha256sha256(writer.toBuffer());
             hashes.push(hash);
         }
         return hashes;
@@ -201,8 +208,8 @@ class Transaction {
                 size += 1;
             }
             for (let i = 0; i < size; i += 2) {
-                const buf = Buffer.concat([hashes[j + i], hashes[j + i + 1]]);
-                hashes.push(hash_js_1.Hash.sha256sha256(buf));
+                const buf = util_1.BufferUtil.concat([hashes[j + i], hashes[j + i + 1]]);
+                hashes.push(hash_1.Hash.sha256sha256(buf));
             }
             j += size;
         }
@@ -268,7 +275,7 @@ class Transaction {
         if (sigError)
             return sigError;
         if (this._hasInvalidSatoshis()) {
-            return new errors_js_1.BitcoreError('Invalid satoshis in outputs');
+            return new errors_1.BitcoreError('Invalid satoshis in outputs');
         }
         return null;
     }
@@ -278,7 +285,7 @@ class Transaction {
         }
         for (const output of this.outputs) {
             if (output.satoshis < Transaction.DUST_AMOUNT && !output.isOpReturn()) {
-                return new errors_js_1.BitcoreError('Dust outputs not allowed');
+                return new errors_1.BitcoreError('Dust outputs not allowed');
             }
         }
         return null;
@@ -288,7 +295,7 @@ class Transaction {
             return null;
         }
         if (!this.isFullySigned()) {
-            return new errors_js_1.BitcoreError('Transaction is not fully signed');
+            return new errors_1.BitcoreError('Transaction is not fully signed');
         }
         return null;
     }
@@ -309,12 +316,12 @@ class Transaction {
         return true;
     }
     toBuffer() {
-        const writer = new bufferwriter_js_1.BufferWriter();
+        const writer = new bufferwriter_1.BufferWriter();
         return this.toBufferWriter(writer).toBuffer();
     }
     toBufferWriter(writer) {
         if (!writer) {
-            writer = new bufferwriter_js_1.BufferWriter();
+            writer = new bufferwriter_1.BufferWriter();
         }
         writer.writeInt32LE(this.version);
         writer.writeVarintNum(this.inputs.length);
@@ -323,34 +330,34 @@ class Transaction {
         }
         writer.writeVarintNum(this.outputs.length);
         for (const output of this.outputs) {
-            writer.writeUInt64LEBN(new bn_js_1.BN(output.satoshis));
+            writer.writeUInt64LEBN(new bn_1.BN(output.satoshis));
             writer.writeVarLengthBuffer(output.scriptBuffer);
         }
         writer.writeUInt32LE(this.nLockTime);
         return writer;
     }
     fromBuffer(buffer) {
-        const reader = new bufferreader_js_1.BufferReader(buffer);
+        const reader = new bufferreader_1.BufferReader(buffer);
         return this.fromBufferReader(reader);
     }
     fromBufferReader(reader) {
-        preconditions_js_1.Preconditions.checkArgument(!reader.finished(), 'No transaction data received');
+        preconditions_1.Preconditions.checkArgument(!reader.finished(), 'No transaction data received');
         this.version = reader.readInt32LE();
         const sizeTxIns = reader.readVarintNum();
         for (let i = 0; i < sizeTxIns; i++) {
-            const input = input_js_1.Input.fromBufferReader(reader);
+            const input = input_1.Input.fromBufferReader(reader);
             this.inputs.push(input);
         }
         const sizeTxOuts = reader.readVarintNum();
         for (let i = 0; i < sizeTxOuts; i++) {
-            const output = output_js_1.Output.fromBufferReader(reader);
+            const output = output_1.Output.fromBufferReader(reader);
             this.outputs.push(output);
         }
         this.nLockTime = reader.readUInt32LE();
         return this;
     }
     fromString(str) {
-        return this.fromBuffer(Buffer.from(str, 'hex'));
+        return this.fromBuffer(util_1.BufferUtil.from(str, 'hex'));
     }
     toObject() {
         const inputs = this.inputs.map(input => input.toObject());
@@ -377,7 +384,7 @@ class Transaction {
     }
     toJSON = this.toObject;
     fromObject(arg) {
-        preconditions_js_1.Preconditions.checkArgument(typeof arg === 'object' && arg !== null, 'Must provide an object to deserialize a transaction');
+        preconditions_1.Preconditions.checkArgument(typeof arg === 'object' && arg !== null, 'Must provide an object to deserialize a transaction');
         let transaction;
         if (arg instanceof Transaction) {
             const obj = arg.toObject();
@@ -400,7 +407,7 @@ class Transaction {
         this.nLockTime = transaction.nLockTime || DEFAULT_NLOCKTIME;
         if (transaction.inputs) {
             for (const inputData of transaction.inputs) {
-                const input = new input_js_1.Input({
+                const input = new input_1.Input({
                     prevTxId: inputData.prevTxId,
                     outputIndex: inputData.outputIndex,
                     sequenceNumber: inputData.sequenceNumber,
@@ -413,7 +420,7 @@ class Transaction {
         }
         if (transaction.outputs) {
             for (const outputData of transaction.outputs) {
-                const output = new output_js_1.Output({
+                const output = new output_1.Output({
                     satoshis: outputData.satoshis,
                     script: outputData.script,
                 });
@@ -423,7 +430,7 @@ class Transaction {
         if (transaction.changeScript) {
             this._changeScript =
                 typeof transaction.changeScript === 'string'
-                    ? script_js_1.Script.fromString(transaction.changeScript)
+                    ? script_1.Script.fromString(transaction.changeScript)
                     : transaction.changeScript;
         }
         if (transaction.changeIndex !== undefined) {
@@ -465,7 +472,7 @@ class Transaction {
         if (exists) {
             return this;
         }
-        const utxo = utxos instanceof unspentoutput_js_1.UnspentOutput ? utxos : new unspentoutput_js_1.UnspentOutput(utxos);
+        const utxo = utxos instanceof unspentoutput_1.UnspentOutput ? utxos : new unspentoutput_1.UnspentOutput(utxos);
         if (pubkeys && threshold) {
             this._fromMultisigUtxo(utxo, pubkeys, threshold, opts);
         }
@@ -475,7 +482,7 @@ class Transaction {
         return this;
     }
     change(address) {
-        this._changeScript = script_js_1.Script.fromAddress(address);
+        this._changeScript = script_1.Script.fromAddress(address);
         this._updateChangeOutput();
         return this;
     }
@@ -486,9 +493,9 @@ class Transaction {
             }
             return this;
         }
-        preconditions_js_1.Preconditions.checkArgument(js_js_1.JSUtil.isNaturalNumber(amount), 'Amount is expected to be a positive integer');
-        this.addOutput(new output_js_1.Output({
-            script: script_js_1.Script.fromAddress(new address_js_1.Address(address)),
+        preconditions_1.Preconditions.checkArgument(js_1.JSUtil.isNaturalNumber(amount), 'Amount is expected to be a positive integer');
+        this.addOutput(new output_1.Output({
+            script: script_1.Script.fromAddress(new address_1.Address(address)),
             satoshis: amount,
         }));
         return this;
@@ -504,34 +511,34 @@ class Transaction {
         return this;
     }
     signSchnorr(privateKey) {
-        return this.sign(privateKey, signature_js_1.Signature.SIGHASH_ALL | signature_js_1.Signature.SIGHASH_LOTUS, 'schnorr');
+        return this.sign(privateKey, signature_1.Signature.SIGHASH_ALL | signature_1.Signature.SIGHASH_LOTUS, 'schnorr');
     }
     getMuSig2Inputs() {
-        return this.inputs.filter(input => input instanceof input_js_1.MuSigTaprootInput);
+        return this.inputs.filter(input => input instanceof input_1.MuSig2TaprootInput);
     }
     getMuSig2Sighash(inputIndex) {
         const input = this.inputs[inputIndex];
-        if (!(input instanceof input_js_1.MuSigTaprootInput)) {
-            throw new Error(`Input ${inputIndex} is not a MuSigTaprootInput`);
+        if (!(input instanceof input_1.MuSig2TaprootInput)) {
+            throw new Error(`Input ${inputIndex} is not a MuSig2TaprootInput`);
         }
         if (!input.output) {
             throw new Error(`Input ${inputIndex} is missing output information`);
         }
-        const sigtype = signature_js_1.Signature.SIGHASH_ALL | signature_js_1.Signature.SIGHASH_LOTUS;
-        return (0, sighash_js_2.sighash)(this, sigtype, inputIndex, input.output.script, new bn_js_1.BN(input.output.satoshis));
+        const sigtype = signature_1.Signature.SIGHASH_ALL | signature_1.Signature.SIGHASH_LOTUS;
+        return (0, sighash_2.sighash)(this, sigtype, inputIndex, input.output.script, new bn_1.BN(input.output.satoshis));
     }
     addMuSig2Nonce(inputIndex, signerIndex, nonce) {
         const input = this.inputs[inputIndex];
-        if (!(input instanceof input_js_1.MuSigTaprootInput)) {
-            throw new Error(`Input ${inputIndex} is not a MuSigTaprootInput`);
+        if (!(input instanceof input_1.MuSig2TaprootInput)) {
+            throw new Error(`Input ${inputIndex} is not a MuSig2TaprootInput`);
         }
         input.addPublicNonce(signerIndex, nonce);
         return this;
     }
     addMuSig2PartialSignature(inputIndex, signerIndex, partialSig) {
         const input = this.inputs[inputIndex];
-        if (!(input instanceof input_js_1.MuSigTaprootInput)) {
-            throw new Error(`Input ${inputIndex} is not a MuSigTaprootInput`);
+        if (!(input instanceof input_1.MuSig2TaprootInput)) {
+            throw new Error(`Input ${inputIndex} is not a MuSig2TaprootInput`);
         }
         input.addPartialSignature(signerIndex, partialSig);
         return this;
@@ -540,36 +547,36 @@ class Transaction {
         const musigInputs = this.getMuSig2Inputs();
         for (let i = 0; i < this.inputs.length; i++) {
             const input = this.inputs[i];
-            if (input instanceof input_js_1.MuSigTaprootInput) {
+            if (input instanceof input_1.MuSig2TaprootInput) {
                 if (!input.hasAllPartialSignatures()) {
                     throw new Error(`MuSig2 input ${i} is missing partial signatures. ` +
                         `Has ${input.partialSignatures?.size || 0} of ${input.keyAggContext?.pubkeys.length || 0}`);
                 }
                 const sighash = this.getMuSig2Sighash(i);
-                input.finalizeMuSigSignature(this, sighash);
+                input.finalizeMuSig2Signature(this, sighash);
             }
         }
         return this;
     }
     getSignatures(privKey, sigtype, signingMethod) {
-        const privateKey = new privatekey_js_1.PrivateKey(privKey);
+        const privateKey = new privatekey_1.PrivateKey(privKey);
         const results = [];
-        const hashData = hash_js_1.Hash.sha256ripemd160(privateKey.publicKey.toBuffer());
+        const hashData = hash_1.Hash.sha256ripemd160(privateKey.publicKey.toBuffer());
         for (let index = 0; index < this.inputs.length; index++) {
             const input = this.inputs[index];
             let inputSigtype = sigtype;
             if (!inputSigtype) {
-                if (input.output?.script.isPayToTaproot()) {
+                if (input.output?.script.isTaprootOut()) {
                     const taprootInput = input;
                     if (taprootInput.hasScriptTree()) {
-                        inputSigtype = signature_js_1.Signature.SIGHASH_ALL | signature_js_1.Signature.SIGHASH_FORKID;
+                        inputSigtype = signature_1.Signature.SIGHASH_ALL | signature_1.Signature.SIGHASH_FORKID;
                     }
                     else {
-                        inputSigtype = signature_js_1.Signature.SIGHASH_ALL | signature_js_1.Signature.SIGHASH_LOTUS;
+                        inputSigtype = signature_1.Signature.SIGHASH_ALL | signature_1.Signature.SIGHASH_LOTUS;
                     }
                 }
                 else {
-                    inputSigtype = signature_js_1.Signature.SIGHASH_ALL | signature_js_1.Signature.SIGHASH_FORKID;
+                    inputSigtype = signature_1.Signature.SIGHASH_ALL | signature_1.Signature.SIGHASH_FORKID;
                 }
             }
             const signatures = input.getSignatures(this, privateKey, index, inputSigtype, hashData, signingMethod);
@@ -588,10 +595,10 @@ class Transaction {
         return input.isValidSignature(this, sig);
     }
     verifySignature(sig, pubkey, nin, subscript, satoshisBN, flags, signingMethod) {
-        return (0, sighash_js_1.verify)(this, sig, pubkey, nin, subscript, satoshisBN, flags, signingMethod);
+        return (0, sighash_1.verify)(this, sig, pubkey, nin, subscript, satoshisBN, flags, signingMethod);
     }
     lockUntilDate(time) {
-        preconditions_js_1.Preconditions.checkArgument(!!time, 'time is required');
+        preconditions_1.Preconditions.checkArgument(!!time, 'time is required');
         if (typeof time === 'number' &&
             time < Transaction.NLOCKTIME_BLOCKHEIGHT_LIMIT) {
             throw new Error('Lock time too early');
@@ -600,15 +607,15 @@ class Transaction {
             time = time.getTime() / 1000;
         }
         for (let i = 0; i < this.inputs.length; i++) {
-            if (this.inputs[i].sequenceNumber === input_js_1.Input.DEFAULT_SEQNUMBER) {
-                this.inputs[i].sequenceNumber = input_js_1.Input.DEFAULT_LOCKTIME_SEQNUMBER;
+            if (this.inputs[i].sequenceNumber === input_1.Input.DEFAULT_SEQNUMBER) {
+                this.inputs[i].sequenceNumber = input_1.Input.DEFAULT_LOCKTIME_SEQNUMBER;
             }
         }
         this.nLockTime = time;
         return this;
     }
     lockUntilBlockHeight(height) {
-        preconditions_js_1.Preconditions.checkArgument(typeof height === 'number', 'height must be a number');
+        preconditions_1.Preconditions.checkArgument(typeof height === 'number', 'height must be a number');
         if (height >= Transaction.NLOCKTIME_BLOCKHEIGHT_LIMIT) {
             throw new Error('Block height too high');
         }
@@ -616,8 +623,8 @@ class Transaction {
             throw new Error('NLockTime out of range');
         }
         for (let i = 0; i < this.inputs.length; i++) {
-            if (this.inputs[i].sequenceNumber === input_js_1.Input.DEFAULT_SEQNUMBER) {
-                this.inputs[i].sequenceNumber = input_js_1.Input.DEFAULT_LOCKTIME_SEQNUMBER;
+            if (this.inputs[i].sequenceNumber === input_1.Input.DEFAULT_SEQNUMBER) {
+                this.inputs[i].sequenceNumber = input_1.Input.DEFAULT_LOCKTIME_SEQNUMBER;
             }
         }
         this.nLockTime = height;
@@ -636,8 +643,8 @@ class Transaction {
         return this.inputs.every(input => !!input.output);
     }
     addData(value) {
-        this.addOutput(new output_js_1.Output({
-            script: script_js_1.Script.buildDataOut(value),
+        this.addOutput(new output_1.Output({
+            script: script_1.Script.buildDataOut(value),
             satoshis: 0,
         }));
         return this;
@@ -663,7 +670,7 @@ class Transaction {
                 x.i = i++;
             });
             copy.sort((first, second) => {
-                const prevTxIdCompare = Buffer.compare(first.prevTxId, second.prevTxId);
+                const prevTxIdCompare = util_1.BufferUtil.compare(first.prevTxId, second.prevTxId);
                 if (prevTxIdCompare !== 0)
                     return prevTxIdCompare;
                 const outputIndexCompare = first.outputIndex - second.outputIndex;
@@ -685,7 +692,7 @@ class Transaction {
                 const satoshisCompare = first.satoshis - second.satoshis;
                 if (satoshisCompare !== 0)
                     return satoshisCompare;
-                const scriptCompare = Buffer.compare(first.scriptBuffer, second.scriptBuffer);
+                const scriptCompare = util_1.BufferUtil.compare(first.scriptBuffer, second.scriptBuffer);
                 if (scriptCompare !== 0)
                     return scriptCompare;
                 return (first.i -
@@ -820,14 +827,11 @@ class Transaction {
             try {
                 const verifyFlags = flags !== undefined
                     ? flags
-                    : interpreter_js_1.Interpreter.SCRIPT_VERIFY_P2SH |
-                        interpreter_js_1.Interpreter.SCRIPT_VERIFY_STRICTENC |
-                        interpreter_js_1.Interpreter.SCRIPT_VERIFY_DERSIG |
-                        interpreter_js_1.Interpreter.SCRIPT_VERIFY_LOW_S |
-                        interpreter_js_1.Interpreter.SCRIPT_VERIFY_NULLFAIL |
-                        interpreter_js_1.Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID |
-                        interpreter_js_1.Interpreter.SCRIPT_ENABLE_SCHNORR_MULTISIG;
-                const interpreter = new interpreter_js_1.Interpreter();
+                    : interpreter_1.Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID |
+                        interpreter_1.Interpreter.SCRIPT_VERIFY_CLEANSTACK |
+                        interpreter_1.Interpreter.SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS |
+                        interpreter_1.Interpreter.SCRIPT_VERIFY_INPUT_SIGCHECKS;
+                const interpreter = new interpreter_1.Interpreter();
                 const isValid = interpreter.verify(input.script, input.output.script, this, i, verifyFlags, BigInt(input.output.satoshis));
                 if (!isValid) {
                     return {
@@ -851,7 +855,7 @@ class Transaction {
             this.inputs[0].outputIndex === 0xffffffff);
     }
     uncheckedAddInput(input) {
-        preconditions_js_1.Preconditions.checkArgument(input instanceof input_js_1.Input, 'input must be an Input');
+        preconditions_1.Preconditions.checkArgument(input instanceof input_1.Input, 'input must be an Input');
         this.inputs.push(input);
         this._inputAmount = undefined;
         this._updateChangeOutput();
@@ -861,7 +865,7 @@ class Transaction {
         const isInvalidSorting = this.outputs.length !== newOutputs.length ||
             this.outputs.some((output, index) => output !== newOutputs[index]);
         if (isInvalidSorting) {
-            throw new errors_js_1.BitcoreError('Invalid sorting: outputs must contain the same elements');
+            throw new errors_1.BitcoreError('Invalid sorting: outputs must contain the same elements');
         }
         if (this._changeIndex !== undefined) {
             const changeOutput = this.outputs[this._changeIndex];
@@ -872,82 +876,90 @@ class Transaction {
     }
     _fromNonP2SH(utxo) {
         let clazz;
-        const unspentOutput = new unspentoutput_js_1.UnspentOutput(utxo);
-        if (unspentOutput.script.isPayToTaproot()) {
+        const unspentOutput = new unspentoutput_1.UnspentOutput(utxo);
+        if (unspentOutput.script.isTaprootOut()) {
             if (unspentOutput.keyAggContext &&
                 unspentOutput.mySignerIndex !== undefined) {
-                clazz = input_js_1.MuSigTaprootInput;
-                const input = new input_js_1.MuSigTaprootInput({
-                    output: new output_js_1.Output({
+                if (!unspentOutput.internalPubKey || !unspentOutput.merkleRoot) {
+                    throw new errors_1.BitcoreError('MuSig2 Taproot input requires internalPubKey and merkleRoot');
+                }
+                clazz = input_1.MuSig2TaprootInput;
+                const input = new input_1.MuSig2TaprootInput({
+                    output: new output_1.Output({
                         script: unspentOutput.script,
                         satoshis: unspentOutput.satoshis,
                     }),
                     prevTxId: unspentOutput.txId,
                     outputIndex: unspentOutput.outputIndex,
-                    script: new script_js_1.Script(),
+                    script: new script_1.Script(),
                     keyAggContext: unspentOutput.keyAggContext,
                     mySignerIndex: unspentOutput.mySignerIndex,
+                    internalPubKey: unspentOutput.internalPubKey,
+                    merkleRoot: unspentOutput.merkleRoot,
                 });
                 this.addInput(input);
                 return;
             }
-            clazz = input_js_1.TaprootInput;
-            const taprootInput = new input_js_1.TaprootInput({
-                output: new output_js_1.Output({
+            if (!unspentOutput.internalPubKey) {
+                throw new errors_1.BitcoreError('Taproot input requires internalPubKey');
+            }
+            clazz = input_1.TaprootInput;
+            const taprootInput = new input_1.TaprootInput({
+                output: new output_1.Output({
                     script: unspentOutput.script,
                     satoshis: unspentOutput.satoshis,
                 }),
                 prevTxId: unspentOutput.txId,
                 outputIndex: unspentOutput.outputIndex,
-                script: new script_js_1.Script(),
+                script: new script_1.Script(),
                 internalPubKey: unspentOutput.internalPubKey,
-                merkleRoot: unspentOutput.merkleRoot || Buffer.alloc(32),
+                merkleRoot: unspentOutput.merkleRoot || util_1.BufferUtil.alloc(32),
             });
             this.addInput(taprootInput);
             return;
         }
-        else if (unspentOutput.script.isPayToPublicKeyHash()) {
-            clazz = input_js_1.PublicKeyHashInput;
+        else if (unspentOutput.script.isPublicKeyHashOut()) {
+            clazz = input_1.PublicKeyHashInput;
         }
         else if (unspentOutput.script.isPublicKeyOut()) {
-            clazz = input_js_1.PublicKeyInput;
+            clazz = input_1.PublicKeyInput;
         }
         else {
-            clazz = input_js_1.Input;
+            clazz = input_1.Input;
         }
         this.addInput(new clazz({
-            output: new output_js_1.Output({
+            output: new output_1.Output({
                 script: unspentOutput.script,
                 satoshis: unspentOutput.satoshis,
             }),
             prevTxId: unspentOutput.txId,
             outputIndex: unspentOutput.outputIndex,
-            script: new script_js_1.Script(),
+            script: new script_1.Script(),
         }));
     }
     _fromMultisigUtxo(utxo, pubkeys, threshold, opts) {
-        preconditions_js_1.Preconditions.checkArgument(threshold <= pubkeys.length, 'Number of required signatures must be greater than the number of public keys');
-        const unspentOutput = new unspentoutput_js_1.UnspentOutput(utxo);
+        preconditions_1.Preconditions.checkArgument(threshold <= pubkeys.length, 'Number of required signatures must be greater than the number of public keys');
+        const unspentOutput = new unspentoutput_1.UnspentOutput(utxo);
         if (unspentOutput.script.isMultisigOut()) {
-            this.addInput(new input_js_1.MultisigInput(new input_js_1.Input({
-                output: new output_js_1.Output({
+            this.addInput(new input_1.MultisigInput(new input_1.Input({
+                output: new output_1.Output({
                     script: unspentOutput.script,
                     satoshis: unspentOutput.satoshis,
                 }),
                 prevTxId: unspentOutput.txId,
                 outputIndex: unspentOutput.outputIndex,
-                script: new script_js_1.Script(),
+                script: new script_1.Script(),
             }), pubkeys, threshold, undefined, opts));
         }
-        else if (unspentOutput.script.isPayToScriptHash()) {
-            this.addInput(new input_js_1.MultisigScriptHashInput(new input_js_1.Input({
-                output: new output_js_1.Output({
+        else if (unspentOutput.script.isScriptHashOut()) {
+            this.addInput(new input_1.MultisigScriptHashInput(new input_1.Input({
+                output: new output_1.Output({
                     script: unspentOutput.script,
                     satoshis: unspentOutput.satoshis,
                 }),
                 prevTxId: unspentOutput.txId,
                 outputIndex: unspentOutput.outputIndex,
-                script: new script_js_1.Script(),
+                script: new script_1.Script(),
             }), pubkeys, threshold, undefined, opts));
         }
         else {
@@ -967,7 +979,7 @@ class Transaction {
         const changeAmount = available - fee;
         if (changeAmount >= Transaction.DUST_AMOUNT) {
             this._changeIndex = this.outputs.length;
-            this._addOutput(new output_js_1.Output({
+            this._addOutput(new output_1.Output({
                 script: this._changeScript,
                 satoshis: changeAmount,
             }));