xpi-ts 0.2.13 → 0.2.15

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

@@ -1,40 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MuSigTaprootInput = exports.TaprootInput = exports.PublicKeyHashInput = exports.PublicKeyInput = exports.MultisigScriptHashInput = exports.MultisigInput = exports.Input = void 0;
-const preconditions_js_1 = require("../util/preconditions.js");
-const errors_js_1 = require("../errors.js");
-const bufferwriter_js_1 = require("../encoding/bufferwriter.js");
-const buffer_js_1 = require("../util/buffer.js");
-const js_js_1 = require("../util/js.js");
-const script_js_1 = require("../script.js");
-const opcode_js_1 = require("../opcode.js");
-const bn_js_1 = require("../crypto/bn.js");
-const output_js_1 = require("./output.js");
-const signature_js_1 = require("../crypto/signature.js");
-const signature_js_2 = require("./signature.js");
-const sighash_js_1 = require("./sighash.js");
-const hash_js_1 = require("../crypto/hash.js");
-const taproot_js_1 = require("../taproot.js");
-const musig2_js_1 = require("../crypto/musig2.js");
+exports.MuSig2TaprootInput = exports.TaprootInput = exports.PublicKeyHashInput = exports.PublicKeyInput = exports.MultisigScriptHashInput = exports.MultisigInput = exports.Input = void 0;
+const preconditions_1 = require("../util/preconditions");
+const errors_1 = require("../errors");
+const bufferwriter_1 = require("../encoding/bufferwriter");
+const buffer_1 = require("../util/buffer");
+const js_1 = require("../util/js");
+const script_1 = require("../script");
+const opcode_1 = require("../opcode");
+const crypto_1 = require("../crypto");
+const output_1 = require("./output");
+const musig2_1 = require("../crypto/musig2");
+const signature_1 = require("../crypto/signature");
+const signature_2 = require("./signature");
+const sighash_1 = require("./sighash");
+const taproot_1 = require("../script/taproot");
+const NULL_INDEX = 0xffffffff;
+const NULL_HASH = buffer_1.BufferUtil.alloc(32);
 class Input {
     static MAXINT = 0xffffffff;
     static DEFAULT_SEQNUMBER = 0xffffffff;
     static DEFAULT_LOCKTIME_SEQNUMBER = 0xfffffffe;
     static DEFAULT_RBF_SEQNUMBER = 0xfffffffd;
-    static SEQUENCE_LOCKTIME_TYPE_FLAG = 0x400000;
-    static SEQUENCE_LOCKTIME_DISABLE_FLAG = 0x80000000;
-    static SEQUENCE_LOCKTIME_MASK = 0xffff;
+    static SEQUENCE_LOCKTIME_DISABLE_FLAG = 1 << 31;
+    static SEQUENCE_LOCKTIME_TYPE_FLAG = 1 << 22;
+    static SEQUENCE_LOCKTIME_MASK = 0x0000ffff;
     static SEQUENCE_LOCKTIME_GRANULARITY = 512;
     static SEQUENCE_BLOCKDIFF_LIMIT = 0xffff;
-    static PublicKey;
-    static PublicKeyHash;
-    static Multisig;
-    static MultisigScriptHash;
-    static Taproot;
-    static MuSigTaproot;
-    static P2PKH;
-    static P2SH;
-    static P2TR;
     prevTxId;
     outputIndex;
     sequenceNumber;
@@ -50,20 +42,20 @@ class Input {
         return new Input(params);
     }
     static fromObject(obj) {
-        preconditions_js_1.Preconditions.checkArgument(typeof obj === 'object' && obj !== null, 'Must provide an object');
+        preconditions_1.Preconditions.checkArgument(typeof obj === 'object' && obj !== null, 'Must provide an object');
         const input = new Input();
         return input._fromObject(obj);
     }
     _fromObject(params) {
         let prevTxId;
-        if (typeof params.prevTxId === 'string' && js_js_1.JSUtil.isHexa(params.prevTxId)) {
-            prevTxId = Buffer.from(params.prevTxId, 'hex');
+        if (typeof params.prevTxId === 'string' && js_1.JSUtil.isHexa(params.prevTxId)) {
+            prevTxId = buffer_1.BufferUtil.from(params.prevTxId, 'hex');
         }
-        else if (Buffer.isBuffer(params.prevTxId)) {
+        else if (buffer_1.BufferUtil.isBuffer(params.prevTxId)) {
             prevTxId = params.prevTxId;
         }
         else {
-            prevTxId = Buffer.alloc(0);
+            prevTxId = buffer_1.BufferUtil.alloc(0);
         }
         this.output = params.output;
         this.prevTxId = prevTxId;
@@ -73,7 +65,7 @@ class Input {
                 ? params.sequenceNumber
                 : Input.DEFAULT_SEQNUMBER;
         if (params.scriptBuffer === undefined && params.script === undefined) {
-            throw new errors_js_1.BitcoreError.Transaction.Input.MissingScript();
+            throw new errors_1.BitcoreError.Transaction.Input.MissingScript();
         }
         this.setScript(params.scriptBuffer || params.script);
         return this;
@@ -83,7 +75,7 @@ class Input {
             return null;
         }
         if (!this._script) {
-            this._script = new script_js_1.Script(this._scriptBuffer);
+            this._script = new script_1.Script(this._scriptBuffer);
             this._script._isInput = true;
         }
         return this._script;
@@ -93,26 +85,26 @@ class Input {
     }
     setScript(script) {
         this._script = undefined;
-        if (script instanceof script_js_1.Script) {
+        if (script instanceof script_1.Script) {
             this._script = script;
             this._scriptBuffer = script.toBuffer();
         }
         else if (script === null) {
-            this._script = (0, script_js_1.empty)();
+            this._script = script_1.Script.empty();
             this._scriptBuffer = this._script.toBuffer();
         }
-        else if (Buffer.isBuffer(script)) {
+        else if (buffer_1.BufferUtil.isBuffer(script)) {
             this._scriptBuffer = script;
-            this._script = script_js_1.Script.fromBuffer(script);
+            this._script = script_1.Script.fromBuffer(script);
         }
         else if (typeof script === 'string') {
-            if (js_js_1.JSUtil.isHexa(script)) {
-                this._scriptBuffer = Buffer.from(script, 'hex');
-                this._script = script_js_1.Script.fromBuffer(this._scriptBuffer);
+            if (js_1.JSUtil.isHexa(script)) {
+                this._scriptBuffer = buffer_1.BufferUtil.from(script, 'hex');
+                this._script = script_1.Script.fromBuffer(this._scriptBuffer);
             }
             else {
-                this._scriptBuffer = Buffer.from(script, 'utf8');
-                this._script = script_js_1.Script.fromBuffer(this._scriptBuffer);
+                this._scriptBuffer = buffer_1.BufferUtil.from(script, 'utf8');
+                this._script = script_1.Script.fromBuffer(this._scriptBuffer);
             }
         }
         else {
@@ -121,12 +113,10 @@ class Input {
         return this;
     }
     isNull() {
-        return (this.prevTxId.toString('hex') ===
-            '0000000000000000000000000000000000000000000000000000000000000000' &&
-            this.outputIndex === 0xffffffff);
+        return this.prevTxId === NULL_HASH && this.outputIndex === NULL_INDEX;
     }
     isFinal() {
-        return this.sequenceNumber !== 4294967295;
+        return this.sequenceNumber !== Input.DEFAULT_SEQNUMBER;
     }
     hasSequence() {
         return this.sequenceNumber !== Input.DEFAULT_SEQNUMBER;
@@ -163,7 +153,7 @@ class Input {
     }
     toObject() {
         const obj = {
-            prevTxId: Buffer.from(this.prevTxId).toString('hex'),
+            prevTxId: buffer_1.BufferUtil.from(this.prevTxId).toString('hex'),
             outputIndex: this.outputIndex,
             sequenceNumber: this.sequenceNumber,
             script: this._scriptBuffer.toString('hex'),
@@ -179,7 +169,9 @@ class Input {
         }
         return obj;
     }
-    toJSON = this.toObject;
+    toJSON() {
+        return this.toObject();
+    }
     static fromBufferReader(br) {
         const input = new Input();
         input.prevTxId = br.readReverse(32);
@@ -189,7 +181,7 @@ class Input {
         return input;
     }
     toBuffer() {
-        const bw = new bufferwriter_js_1.BufferWriter();
+        const bw = new bufferwriter_1.BufferWriter();
         bw.writeReverse(this.prevTxId);
         bw.writeUInt32LE(this.outputIndex);
         bw.writeVarLengthBuffer(this._scriptBuffer);
@@ -198,7 +190,7 @@ class Input {
     }
     toBufferWriter(writer) {
         if (!writer) {
-            writer = new bufferwriter_js_1.BufferWriter();
+            writer = new bufferwriter_1.BufferWriter();
         }
         writer.writeReverse(this.prevTxId);
         writer.writeUInt32LE(this.outputIndex);
@@ -211,7 +203,7 @@ class Input {
     getSize() {
         return (32 +
             4 +
-            bufferwriter_js_1.BufferWriter.varintBufNum(this._scriptBuffer.length).length +
+            bufferwriter_1.BufferWriter.varintBufNum(this._scriptBuffer.length).length +
             this._scriptBuffer.length +
             4);
     }
@@ -221,32 +213,32 @@ class Input {
         }
         return (this.prevTxId.length === 32 &&
             this.outputIndex >= 0 &&
-            this.outputIndex <= 0xffffffff &&
+            this.outputIndex <= NULL_INDEX &&
             this._scriptBuffer.length > 0);
     }
     clone() {
         return new Input({
-            prevTxId: Buffer.from(this.prevTxId),
+            prevTxId: buffer_1.BufferUtil.from(this.prevTxId),
             outputIndex: this.outputIndex,
             sequenceNumber: this.sequenceNumber,
-            scriptBuffer: Buffer.from(this._scriptBuffer),
+            scriptBuffer: buffer_1.BufferUtil.from(this._scriptBuffer),
             output: this.output,
         });
     }
     getSignatures(transaction, privateKey, index, sigtype, hashData, signingMethod) {
-        preconditions_js_1.Preconditions.checkState(this.output instanceof output_js_1.Output, 'Output is required');
-        sigtype = sigtype || signature_js_1.Signature.SIGHASH_ALL | signature_js_1.Signature.SIGHASH_FORKID;
+        preconditions_1.Preconditions.checkState(this.output instanceof output_1.Output, 'Output is required');
+        sigtype = sigtype || signature_1.Signature.SIGHASH_ALL | signature_1.Signature.SIGHASH_FORKID;
         const publicKey = privateKey.publicKey;
         if (this.output.script.isPublicKeyHashOut()) {
-            const addressHash = hashData || hash_js_1.Hash.sha256ripemd160(publicKey.toBuffer());
-            if (buffer_js_1.BufferUtil.equals(addressHash, this.output.script.getPublicKeyHash())) {
+            const addressHash = hashData || crypto_1.Hash.sha256ripemd160(publicKey.toBuffer());
+            if (buffer_1.BufferUtil.equals(addressHash, this.output.script.getPublicKeyHash())) {
                 return [
-                    new signature_js_2.TransactionSignature({
+                    new signature_2.TransactionSignature({
                         publicKey: publicKey,
                         prevTxId: this.prevTxId,
                         outputIndex: this.outputIndex,
                         inputIndex: index,
-                        signature: (0, sighash_js_1.sign)(transaction, privateKey, sigtype, index, this.output.script, new bn_js_1.BN(this.output.satoshis.toString()), undefined, signingMethod),
+                        signature: (0, sighash_1.sign)(transaction, privateKey, sigtype, index, this.output.script, new crypto_1.BN(this.output.satoshis.toString()), undefined, signingMethod),
                         sigtype: sigtype,
                     }),
                 ];
@@ -256,12 +248,12 @@ class Input {
             if (publicKey.toString() ===
                 this.output.script.getPublicKey().toString('hex')) {
                 return [
-                    new signature_js_2.TransactionSignature({
+                    new signature_2.TransactionSignature({
                         publicKey: publicKey,
                         prevTxId: this.prevTxId,
                         outputIndex: this.outputIndex,
                         inputIndex: index,
-                        signature: (0, sighash_js_1.sign)(transaction, privateKey, sigtype, index, this.output.script, new bn_js_1.BN(this.output.satoshis.toString()), undefined, signingMethod),
+                        signature: (0, sighash_1.sign)(transaction, privateKey, sigtype, index, this.output.script, new crypto_1.BN(this.output.satoshis.toString()), undefined, signingMethod),
                         sigtype: sigtype,
                     }),
                 ];
@@ -273,20 +265,20 @@ class Input {
         throw new Error('Input#isFullySigned');
     }
     addSignature(transaction, signature, signingMethod) {
-        preconditions_js_1.Preconditions.checkState(this.isValidSignature(transaction, signature, signingMethod), 'Signature is invalid');
+        preconditions_1.Preconditions.checkState(this.isValidSignature(transaction, signature, signingMethod), 'Signature is invalid');
         if (this.output?.script.isPublicKeyHashOut()) {
-            const script = new script_js_1.Script();
+            const script = new script_1.Script();
             script.add(signature.signature.toTxFormat(signingMethod));
             script.add(signature.publicKey.toBuffer());
             this.setScript(script);
         }
         else if (this.output?.script.isPublicKeyOut()) {
-            const script = new script_js_1.Script();
+            const script = new script_1.Script();
             script.add(signature.signature.toTxFormat(signingMethod));
             this.setScript(script);
         }
         else {
-            const script = new script_js_1.Script();
+            const script = new script_1.Script();
             script.add(signature.signature.toTxFormat(signingMethod));
             if (signature.publicKey) {
                 script.add(signature.publicKey.toBuffer());
@@ -299,10 +291,10 @@ class Input {
         throw new Error('Input#clearSignatures');
     }
     isValidSignature(transaction, signature, signingMethod) {
-        return (0, sighash_js_1.verify)(transaction, signature.signature, signature.publicKey, signature.inputIndex, this.output.script, new bn_js_1.BN(this.output.satoshis.toString()), undefined, signingMethod);
+        return (0, sighash_1.verify)(transaction, signature.signature, signature.publicKey, signature.inputIndex, this.output.script, new crypto_1.BN(this.output.satoshis.toString()), undefined, signingMethod);
     }
     lockForSeconds(seconds) {
-        preconditions_js_1.Preconditions.checkArgument(typeof seconds === 'number', 'seconds must be a number');
+        preconditions_1.Preconditions.checkArgument(typeof seconds === 'number', 'seconds must be a number');
         if (seconds < 0 ||
             seconds >=
                 Input.SEQUENCE_LOCKTIME_GRANULARITY * Input.SEQUENCE_LOCKTIME_MASK) {
@@ -313,7 +305,7 @@ class Input {
         return this;
     }
     lockUntilBlockHeight(heightDiff) {
-        preconditions_js_1.Preconditions.checkArgument(typeof heightDiff === 'number', 'heightDiff must be a number');
+        preconditions_1.Preconditions.checkArgument(typeof heightDiff === 'number', 'heightDiff must be a number');
         if (heightDiff < 0 || heightDiff >= Input.SEQUENCE_BLOCKDIFF_LIMIT) {
             throw new Error('Block height out of range');
         }
@@ -373,7 +365,7 @@ class MultisigInput extends Input {
         else {
             this.publicKeys = pubkeys.sort((a, b) => a.toString().localeCompare(b.toString()));
         }
-        preconditions_js_1.Preconditions.checkState(script_js_1.Script.buildMultisigOut(this.publicKeys, threshold).equals(this.output.script), "Provided public keys don't match to the provided output script");
+        preconditions_1.Preconditions.checkState(script_1.Script.buildMultisigOut(this.publicKeys, threshold).equals(this.output.script), "Provided public keys don't match to the provided output script");
         this.publicKeyIndex = {};
         this.publicKeys.forEach((publicKey, index) => {
             this.publicKeyIndex[publicKey.toString()] = index;
@@ -397,7 +389,7 @@ class MultisigInput extends Input {
             if (!signature) {
                 return undefined;
             }
-            return new signature_js_2.TransactionSignature(signature);
+            return new signature_2.TransactionSignature(signature);
         });
     }
     _serializeSignatures() {
@@ -409,17 +401,17 @@ class MultisigInput extends Input {
         });
     }
     getSignatures(transaction, privateKey, index, sigtype, hashData, signingMethod) {
-        preconditions_js_1.Preconditions.checkState(this.output instanceof output_js_1.Output, 'Output is required');
-        sigtype = sigtype || signature_js_1.Signature.SIGHASH_ALL | signature_js_1.Signature.SIGHASH_FORKID;
+        preconditions_1.Preconditions.checkState(this.output instanceof output_1.Output, 'Output is required');
+        sigtype = sigtype || signature_1.Signature.SIGHASH_ALL | signature_1.Signature.SIGHASH_FORKID;
         const results = [];
         this.publicKeys.forEach(publicKey => {
             if (publicKey.toString() === privateKey.publicKey.toString()) {
-                results.push(new signature_js_2.TransactionSignature({
+                results.push(new signature_2.TransactionSignature({
                     publicKey: privateKey.publicKey,
                     prevTxId: this.prevTxId,
                     outputIndex: this.outputIndex,
                     inputIndex: index,
-                    signature: (0, sighash_js_1.sign)(transaction, privateKey, sigtype, index, this.output.script, new bn_js_1.BN(this.output.satoshis.toString()), undefined, signingMethod),
+                    signature: (0, sighash_1.sign)(transaction, privateKey, sigtype, index, this.output.script, new crypto_1.BN(this.output.satoshis.toString()), undefined, signingMethod),
                     sigtype: sigtype,
                 }));
             }
@@ -427,17 +419,17 @@ class MultisigInput extends Input {
         return results;
     }
     addSignature(transaction, signature, signingMethod) {
-        preconditions_js_1.Preconditions.checkState(!this.isFullySigned(), 'All needed signatures have already been added');
-        preconditions_js_1.Preconditions.checkArgument(this.publicKeyIndex[signature.publicKey.toString()] !== undefined, 'Signature has no matching public key');
-        preconditions_js_1.Preconditions.checkState(this.isValidSignature(transaction, signature, signingMethod), 'Invalid signature');
+        preconditions_1.Preconditions.checkState(!this.isFullySigned(), 'All needed signatures have already been added');
+        preconditions_1.Preconditions.checkArgument(this.publicKeyIndex[signature.publicKey.toString()] !== undefined, 'Signature has no matching public key');
+        preconditions_1.Preconditions.checkState(this.isValidSignature(transaction, signature, signingMethod), 'Invalid signature');
         this.signatures[this.publicKeyIndex[signature.publicKey.toString()]] =
             signature;
         this._updateScript(signingMethod);
         return this;
     }
     _updateScript(signingMethod) {
-        const script = new script_js_1.Script();
-        script.add(opcode_js_1.Opcode.OP_0);
+        const script = new script_1.Script();
+        script.add(opcode_1.Opcode.OP_0);
         const signatures = this._createSignatures(signingMethod);
         for (const sig of signatures) {
             script.add(sig);
@@ -449,9 +441,9 @@ class MultisigInput extends Input {
         return this.signatures
             .filter(signature => signature !== undefined)
             .map(signature => {
-            return Buffer.concat([
+            return buffer_1.BufferUtil.concat([
                 signature.signature.toDER(signingMethod),
-                Buffer.from([signature.sigtype]),
+                buffer_1.BufferUtil.from([signature.sigtype]),
             ]);
         });
     }
@@ -475,7 +467,7 @@ class MultisigInput extends Input {
         });
     }
     isValidSignature(transaction, signature, signingMethod) {
-        return (0, sighash_js_1.verify)(transaction, signature.signature, signature.publicKey, signature.inputIndex, this.output.script, new bn_js_1.BN(this.output.satoshis.toString()), undefined, signingMethod);
+        return (0, sighash_1.verify)(transaction, signature.signature, signature.publicKey, signature.inputIndex, this.output.script, new crypto_1.BN(this.output.satoshis.toString()), undefined, signingMethod);
     }
     normalizeSignatures(transaction, input, inputIndex, signatures, publicKeys, signingMethod) {
         return publicKeys
@@ -485,16 +477,16 @@ class MultisigInput extends Input {
                 if (signatureMatch) {
                     return true;
                 }
-                const signature = new signature_js_2.TransactionSignature({
-                    signature: signature_js_1.Signature.fromTxFormat(signatureBuffer),
+                const signature = new signature_2.TransactionSignature({
+                    signature: signature_1.Signature.fromTxFormat(signatureBuffer),
                     publicKey: pubKey,
                     prevTxId: input.prevTxId,
                     outputIndex: input.outputIndex,
                     inputIndex: inputIndex,
-                    sigtype: signature_js_1.Signature.SIGHASH_ALL,
+                    sigtype: signature_1.Signature.SIGHASH_ALL,
                 });
                 signature.signature.nhashtype = signature.sigtype;
-                const isMatch = (0, sighash_js_1.verify)(transaction, signature.signature, signature.publicKey, signature.inputIndex, input.output.script, new bn_js_1.BN(input.output.satoshis.toString()), undefined, signingMethod);
+                const isMatch = (0, sighash_1.verify)(transaction, signature.signature, signature.publicKey, signature.inputIndex, input.output.script, new crypto_1.BN(input.output.satoshis.toString()), undefined, signingMethod);
                 if (isMatch) {
                     signatureMatch = signature;
                     return false;
@@ -541,8 +533,8 @@ class MultisigScriptHashInput extends Input {
         else {
             this.publicKeys = pubkeys.sort((a, b) => a.toString().localeCompare(b.toString()));
         }
-        this.redeemScript = script_js_1.Script.buildMultisigOut(this.publicKeys, threshold, opts);
-        preconditions_js_1.Preconditions.checkState(script_js_1.Script.buildScriptHashOut(this.redeemScript).equals(this.output.script), "Provided public keys don't hash to the provided output");
+        this.redeemScript = script_1.Script.buildMultisigOut(this.publicKeys, threshold, opts);
+        preconditions_1.Preconditions.checkState(script_1.Script.buildScriptHashOut(this.redeemScript).equals(this.output.script), "Provided public keys don't hash to the provided output");
         this.publicKeyIndex = {};
         this.publicKeys.forEach((publicKey, index) => {
             this.publicKeyIndex[publicKey.toString()] = index;
@@ -567,7 +559,7 @@ class MultisigScriptHashInput extends Input {
             if (!signature) {
                 return undefined;
             }
-            return new signature_js_2.TransactionSignature(signature);
+            return new signature_2.TransactionSignature(signature);
         });
     }
     _serializeSignatures() {
@@ -579,17 +571,17 @@ class MultisigScriptHashInput extends Input {
         });
     }
     getSignatures(transaction, privateKey, index, sigtype, hashData, signingMethod) {
-        preconditions_js_1.Preconditions.checkState(this.output instanceof output_js_1.Output, 'Output is required');
-        sigtype = sigtype || signature_js_1.Signature.SIGHASH_ALL | signature_js_1.Signature.SIGHASH_FORKID;
+        preconditions_1.Preconditions.checkState(this.output instanceof output_1.Output, 'Output is required');
+        sigtype = sigtype || signature_1.Signature.SIGHASH_ALL | signature_1.Signature.SIGHASH_FORKID;
         const results = [];
         this.publicKeys.forEach(publicKey => {
             if (publicKey.toString() === privateKey.publicKey.toString()) {
-                results.push(new signature_js_2.TransactionSignature({
+                results.push(new signature_2.TransactionSignature({
                     publicKey: privateKey.publicKey,
                     prevTxId: this.prevTxId,
                     outputIndex: this.outputIndex,
                     inputIndex: index,
-                    signature: (0, sighash_js_1.sign)(transaction, privateKey, sigtype, index, this.redeemScript, new bn_js_1.BN(this.output.satoshis.toString()), undefined, signingMethod),
+                    signature: (0, sighash_1.sign)(transaction, privateKey, sigtype, index, this.redeemScript, new crypto_1.BN(this.output.satoshis.toString()), undefined, signingMethod),
                     sigtype: sigtype,
                 }));
             }
@@ -597,9 +589,9 @@ class MultisigScriptHashInput extends Input {
         return results;
     }
     addSignature(transaction, signature, signingMethod) {
-        preconditions_js_1.Preconditions.checkState(!this.isFullySigned(), 'All needed signatures have already been added');
-        preconditions_js_1.Preconditions.checkArgument(this.publicKeyIndex[signature.publicKey.toString()] !== undefined, 'Signature has no matching public key');
-        preconditions_js_1.Preconditions.checkState(this.isValidSignature(transaction, signature, signingMethod), 'Invalid signature');
+        preconditions_1.Preconditions.checkState(!this.isFullySigned(), 'All needed signatures have already been added');
+        preconditions_1.Preconditions.checkArgument(this.publicKeyIndex[signature.publicKey.toString()] !== undefined, 'Signature has no matching public key');
+        preconditions_1.Preconditions.checkState(this.isValidSignature(transaction, signature, signingMethod), 'Invalid signature');
         this.signatures[this.publicKeyIndex[signature.publicKey.toString()]] =
             signature;
         this.checkBitsField[this.publicKeyIndex[signature.publicKey.toString()]] =
@@ -608,8 +600,8 @@ class MultisigScriptHashInput extends Input {
         return this;
     }
     _updateScript(signingMethod, checkBitsField) {
-        const script = new script_js_1.Script();
-        script.add(opcode_js_1.Opcode.OP_0);
+        const script = new script_1.Script();
+        script.add(opcode_1.Opcode.OP_0);
         const signatures = this._createSignatures(signingMethod);
         for (const sig of signatures) {
             script.add(sig);
@@ -622,9 +614,9 @@ class MultisigScriptHashInput extends Input {
         return this.signatures
             .filter(signature => signature !== undefined)
             .map(signature => {
-            return Buffer.concat([
+            return buffer_1.BufferUtil.concat([
                 signature.signature.toDER(signingMethod),
-                Buffer.from([signature.sigtype]),
+                buffer_1.BufferUtil.from([signature.sigtype]),
             ]);
         });
     }
@@ -649,7 +641,7 @@ class MultisigScriptHashInput extends Input {
     }
     isValidSignature(transaction, signature, signingMethod) {
         signingMethod = signingMethod || 'ecdsa';
-        return (0, sighash_js_1.verify)(transaction, signature.signature, signature.publicKey, signature.inputIndex, this.redeemScript, new bn_js_1.BN(this.output.satoshis.toString()), undefined, signingMethod);
+        return (0, sighash_1.verify)(transaction, signature.signature, signature.publicKey, signature.inputIndex, this.redeemScript, new crypto_1.BN(this.output.satoshis.toString()), undefined, signingMethod);
     }
     normalizeSignatures(transaction, input, inputIndex, signatures, publicKeys, signingMethod) {
         return [];
@@ -664,18 +656,18 @@ exports.MultisigScriptHashInput = MultisigScriptHashInput;
 class PublicKeyInput extends Input {
     static SCRIPT_MAX_SIZE = 73;
     getSignatures(transaction, privateKey, index, sigtype, hashData, signingMethod) {
-        preconditions_js_1.Preconditions.checkState(this.output instanceof output_js_1.Output, 'Output is required');
-        sigtype = sigtype || signature_js_1.Signature.SIGHASH_ALL | signature_js_1.Signature.SIGHASH_FORKID;
+        preconditions_1.Preconditions.checkState(this.output instanceof output_1.Output, 'Output is required');
+        sigtype = sigtype || signature_1.Signature.SIGHASH_ALL | signature_1.Signature.SIGHASH_FORKID;
         const publicKey = privateKey.publicKey;
         if (publicKey.toString() ===
             this.output.script.getPublicKey().toString('hex')) {
             return [
-                new signature_js_2.TransactionSignature({
+                new signature_2.TransactionSignature({
                     publicKey: publicKey,
                     prevTxId: this.prevTxId,
                     outputIndex: this.outputIndex,
                     inputIndex: index,
-                    signature: (0, sighash_js_1.sign)(transaction, privateKey, sigtype, index, this.output.script, new bn_js_1.BN(this.output.satoshis.toString()), undefined, signingMethod),
+                    signature: (0, sighash_1.sign)(transaction, privateKey, sigtype, index, this.output.script, new crypto_1.BN(this.output.satoshis.toString()), undefined, signingMethod),
                     sigtype: sigtype,
                 }),
             ];
@@ -683,14 +675,14 @@ class PublicKeyInput extends Input {
         return [];
     }
     addSignature(transaction, signature, signingMethod) {
-        preconditions_js_1.Preconditions.checkState(this.isValidSignature(transaction, signature, signingMethod), 'Signature is invalid');
-        const script = new script_js_1.Script();
+        preconditions_1.Preconditions.checkState(this.isValidSignature(transaction, signature, signingMethod), 'Signature is invalid');
+        const script = new script_1.Script();
         script.add(signature.signature.toTxFormat(signingMethod));
         this.setScript(script);
         return this;
     }
     clearSignatures() {
-        this.setScript(new script_js_1.Script());
+        this.setScript(new script_1.Script());
         return this;
     }
     isFullySigned() {
@@ -704,17 +696,17 @@ exports.PublicKeyInput = PublicKeyInput;
 class PublicKeyHashInput extends Input {
     static SCRIPT_MAX_SIZE = 73 + 34;
     getSignatures(transaction, privateKey, index, sigtype, hashData, signingMethod) {
-        preconditions_js_1.Preconditions.checkState(this.output instanceof output_js_1.Output, 'Output is required');
-        hashData = hashData || hash_js_1.Hash.sha256ripemd160(privateKey.publicKey.toBuffer());
-        sigtype = sigtype || signature_js_1.Signature.SIGHASH_ALL | signature_js_1.Signature.SIGHASH_FORKID;
-        if (buffer_js_1.BufferUtil.equals(hashData, this.output.script.getPublicKeyHash())) {
+        preconditions_1.Preconditions.checkState(this.output instanceof output_1.Output, 'Output is required');
+        hashData = hashData || crypto_1.Hash.sha256ripemd160(privateKey.publicKey.toBuffer());
+        sigtype = sigtype || signature_1.Signature.SIGHASH_ALL | signature_1.Signature.SIGHASH_FORKID;
+        if (buffer_1.BufferUtil.equals(hashData, this.output.script.getPublicKeyHash())) {
             return [
-                new signature_js_2.TransactionSignature({
+                new signature_2.TransactionSignature({
                     publicKey: privateKey.publicKey,
                     prevTxId: this.prevTxId,
                     outputIndex: this.outputIndex,
                     inputIndex: index,
-                    signature: (0, sighash_js_1.sign)(transaction, privateKey, sigtype, index, this.output.script, new bn_js_1.BN(this.output.satoshis.toString()), undefined, signingMethod),
+                    signature: (0, sighash_1.sign)(transaction, privateKey, sigtype, index, this.output.script, new crypto_1.BN(this.output.satoshis.toString()), undefined, signingMethod),
                     sigtype: sigtype,
                 }),
             ];
@@ -722,15 +714,15 @@ class PublicKeyHashInput extends Input {
         return [];
     }
     addSignature(transaction, signature, signingMethod) {
-        preconditions_js_1.Preconditions.checkState(this.isValidSignature(transaction, signature, signingMethod), 'Signature is invalid');
-        const script = new script_js_1.Script();
+        preconditions_1.Preconditions.checkState(this.isValidSignature(transaction, signature, signingMethod), 'Signature is invalid');
+        const script = new script_1.Script();
         script.add(signature.signature.toTxFormat(signingMethod));
         script.add(signature.publicKey.toBuffer());
         this.setScript(script);
         return this;
     }
     clearSignatures() {
-        this.setScript(new script_js_1.Script());
+        this.setScript(new script_1.Script());
         return this;
     }
     isFullySigned() {
@@ -748,29 +740,27 @@ class TaprootInput extends Input {
     tapScript;
     constructor(params) {
         super(params);
-        if (params) {
-            this.internalPubKey = params.internalPubKey;
-            this.merkleRoot = params.merkleRoot;
-            this.controlBlock = params.controlBlock;
-            this.tapScript = params.tapScript;
-        }
+        this.internalPubKey = params.internalPubKey;
+        this.merkleRoot = params.merkleRoot;
+        this.controlBlock = params.controlBlock;
+        this.tapScript = params.tapScript;
     }
     hasScriptTree() {
         if (!this.merkleRoot || this.merkleRoot.length !== 32) {
             return false;
         }
-        return !this.merkleRoot.equals(Buffer.alloc(32));
+        return !this.merkleRoot.equals(buffer_1.BufferUtil.alloc(32));
     }
     isKeyPathOnly() {
         return !this.hasScriptTree();
     }
     getSignatures(transaction, privateKey, index, sigtype, hashData, signingMethod) {
-        preconditions_js_1.Preconditions.checkState(this.output instanceof output_js_1.Output, 'Output is required');
-        preconditions_js_1.Preconditions.checkState(this.output.script.isPayToTaproot(), 'Output must be Pay-To-Taproot');
+        preconditions_1.Preconditions.checkState(this.output instanceof output_1.Output, 'Output is required');
+        preconditions_1.Preconditions.checkState(this.output.script.isTaprootOut(), 'Output must be Pay-To-Taproot');
         const isKeyPath = this.isKeyPathOnly();
         if (isKeyPath) {
-            sigtype = sigtype || taproot_js_1.TAPROOT_SIGHASH_TYPE;
-            if ((sigtype & 0x60) !== signature_js_1.Signature.SIGHASH_LOTUS) {
+            sigtype = sigtype || taproot_1.TAPROOT_SIGHASH_TYPE;
+            if ((sigtype & 0x60) !== signature_1.Signature.SIGHASH_LOTUS) {
                 throw new Error('Taproot key spend signatures must use "SIGHASH_ALL | SIGHASH_LOTUS" (0x61)');
             }
             signingMethod = signingMethod || 'schnorr';
@@ -780,17 +770,17 @@ class TaprootInput extends Input {
             return this._getKeyPathSignatures(transaction, privateKey, index, sigtype, signingMethod);
         }
         else {
-            sigtype = sigtype || signature_js_1.Signature.SIGHASH_ALL | signature_js_1.Signature.SIGHASH_FORKID;
+            sigtype = sigtype || signature_1.Signature.SIGHASH_ALL | signature_1.Signature.SIGHASH_FORKID;
             signingMethod = signingMethod || 'schnorr';
             return this._getScriptPathSignatures(transaction, privateKey, index, sigtype, signingMethod);
         }
     }
     _getKeyPathSignatures(transaction, privateKey, index, sigtype, signingMethod) {
-        const merkleRoot = this.merkleRoot || Buffer.alloc(32);
-        const tweakedPrivateKey = (0, taproot_js_1.tweakPrivateKey)(privateKey, merkleRoot);
-        const signature = (0, sighash_js_1.sign)(transaction, tweakedPrivateKey, sigtype, index, this.output.script, new bn_js_1.BN(this.output.satoshis.toString()), undefined, signingMethod);
+        const merkleRoot = this.merkleRoot || buffer_1.BufferUtil.alloc(32);
+        const tweakedPrivateKey = (0, taproot_1.tweakPrivateKey)(privateKey, merkleRoot);
+        const signature = (0, sighash_1.sign)(transaction, tweakedPrivateKey, sigtype, index, this.output.script, new crypto_1.BN(this.output.satoshis.toString()), undefined, signingMethod);
         return [
-            new signature_js_2.TransactionSignature({
+            new signature_2.TransactionSignature({
                 publicKey: tweakedPrivateKey.publicKey,
                 prevTxId: this.prevTxId,
                 outputIndex: this.outputIndex,
@@ -801,9 +791,9 @@ class TaprootInput extends Input {
         ];
     }
     _getScriptPathSignatures(transaction, privateKey, index, sigtype, signingMethod) {
-        const signature = (0, sighash_js_1.sign)(transaction, privateKey, sigtype, index, this.tapScript || this.output.script, new bn_js_1.BN(this.output.satoshis.toString()), undefined, signingMethod);
+        const signature = (0, sighash_1.sign)(transaction, privateKey, sigtype, index, this.tapScript || this.output.script, new crypto_1.BN(this.output.satoshis.toString()), undefined, signingMethod);
         return [
-            new signature_js_2.TransactionSignature({
+            new signature_2.TransactionSignature({
                 publicKey: privateKey.publicKey,
                 prevTxId: this.prevTxId,
                 outputIndex: this.outputIndex,
@@ -814,8 +804,8 @@ class TaprootInput extends Input {
         ];
     }
     addSignature(transaction, signature, signingMethod) {
-        preconditions_js_1.Preconditions.checkState(this.isValidSignature(transaction, signature, signingMethod), 'Signature is invalid');
-        const script = new script_js_1.Script();
+        preconditions_1.Preconditions.checkState(this.isValidSignature(transaction, signature, signingMethod), 'Signature is invalid');
+        const script = new script_1.Script();
         if (this.isKeyPathOnly()) {
             script.add(signature.signature.toTxFormat('schnorr'));
         }
@@ -836,15 +826,15 @@ class TaprootInput extends Input {
         return this;
     }
     isValidSignature(transaction, signature, signingMethod) {
-        preconditions_js_1.Preconditions.checkState(this.output instanceof output_js_1.Output, 'Output is required');
+        preconditions_1.Preconditions.checkState(this.output instanceof output_1.Output, 'Output is required');
         signingMethod = signingMethod || 'schnorr';
         if (signingMethod !== 'schnorr') {
             return false;
         }
-        return transaction.verifySignature(signature.signature, signature.publicKey, signature.inputIndex, this.output.script, new bn_js_1.BN(this.output.satoshis), undefined, signingMethod);
+        return transaction.verifySignature(signature.signature, signature.publicKey, signature.inputIndex, this.output.script, new crypto_1.BN(this.output.satoshis), undefined, signingMethod);
     }
     clearSignatures() {
-        this.setScript(new script_js_1.Script());
+        this.setScript(new script_1.Script());
         return this;
     }
     isFullySigned() {
@@ -855,7 +845,7 @@ class TaprootInput extends Input {
     }
 }
 exports.TaprootInput = TaprootInput;
-class MuSigTaprootInput extends TaprootInput {
+class MuSig2TaprootInput extends TaprootInput {
     keyAggContext;
     publicNonces;
     aggregatedNonce;
@@ -863,14 +853,12 @@ class MuSigTaprootInput extends TaprootInput {
     mySignerIndex;
     constructor(params) {
         super(params);
-        if (params) {
-            this.keyAggContext = params.keyAggContext;
-            this.mySignerIndex = params.mySignerIndex;
-            this.publicNonces = new Map();
-            this.partialSignatures = new Map();
-        }
+        this.keyAggContext = params.keyAggContext;
+        this.mySignerIndex = params.mySignerIndex;
+        this.publicNonces = new Map();
+        this.partialSignatures = new Map();
     }
-    initMuSigSession(keyAggContext, mySignerIndex) {
+    initMuSig2Session(keyAggContext, mySignerIndex) {
         this.keyAggContext = keyAggContext;
         this.mySignerIndex = mySignerIndex;
         this.publicNonces = new Map();
@@ -903,7 +891,7 @@ class MuSigTaprootInput extends TaprootInput {
             }
             noncesArray.push(nonce);
         }
-        this.aggregatedNonce = (0, musig2_js_1.musigNonceAgg)(noncesArray);
+        this.aggregatedNonce = (0, musig2_1.muSig2NonceAgg)(noncesArray);
         return this;
     }
     addPartialSignature(signerIndex, partialSig) {
@@ -920,14 +908,14 @@ class MuSigTaprootInput extends TaprootInput {
         const numSigners = this.keyAggContext.pubkeys.length;
         return this.partialSignatures.size === numSigners;
     }
-    finalizeMuSigSignature(transaction, message) {
+    finalizeMuSig2Signature(transaction, message) {
         if (!this.hasAllPartialSignatures()) {
             throw new Error('Not all partial signatures received');
         }
         if (!this.aggregatedNonce) {
             throw new Error('Nonces must be aggregated first');
         }
-        const commitment = (0, taproot_js_1.extractTaprootCommitment)(this.output.script);
+        const commitment = (0, taproot_1.extractTaprootCommitment)(this.output.script);
         const partialSigsArray = [];
         for (let i = 0; i < this.keyAggContext.pubkeys.length; i++) {
             const partialSig = this.partialSignatures.get(i);
@@ -936,8 +924,8 @@ class MuSigTaprootInput extends TaprootInput {
             }
             partialSigsArray.push(partialSig);
         }
-        const finalSignature = (0, musig2_js_1.musigSigAgg)(partialSigsArray, this.aggregatedNonce, message, commitment);
-        const script = new script_js_1.Script();
+        const finalSignature = (0, musig2_1.muSig2SigAgg)(partialSigsArray, this.aggregatedNonce, message, commitment);
+        const script = new script_1.Script();
         script.add(finalSignature.toTxFormat('schnorr'));
         this.setScript(script);
         return this;
@@ -949,13 +937,4 @@ class MuSigTaprootInput extends TaprootInput {
                 this.script.chunks.length > 0));
     }
 }
-exports.MuSigTaprootInput = MuSigTaprootInput;
-Input.PublicKey = PublicKeyInput;
-Input.PublicKeyHash = PublicKeyHashInput;
-Input.Multisig = MultisigInput;
-Input.MultisigScriptHash = MultisigScriptHashInput;
-Input.Taproot = TaprootInput;
-Input.MuSigTaproot = MuSigTaprootInput;
-Input.P2PKH = PublicKeyHashInput;
-Input.P2SH = MultisigScriptHashInput;
-Input.P2TR = TaprootInput;
+exports.MuSig2TaprootInput = MuSig2TaprootInput;