@scure/btc-signer 1.7.0 → 1.8.0

package/transaction.js

@@ -1,23 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transaction = exports.SigHash = exports.SignatureHash = exports.def = exports.Decimal = exports.DEFAULT_SEQUENCE = exports.DEFAULT_LOCKTIME = exports.DEFAULT_VERSION = exports.PRECISION = void 0;
+exports.Transaction = exports.SigHash = exports.SignatureHash = exports.def = exports.Decimal = exports.DEFAULT_SEQUENCE = exports.DEFAULT_LOCKTIME = exports.DEFAULT_VERSION = exports.PRECISION = exports.toVsize = void 0;
 exports.cloneDeep = cloneDeep;
 exports.inputBeforeSign = inputBeforeSign;
+exports.getPrevOut = getPrevOut;
+exports.normalizeInput = normalizeInput;
+exports.getInputType = getInputType;
 exports.PSBTCombine = PSBTCombine;
 exports.bip32Path = bip32Path;
 const base_1 = require("@scure/base");
 const P = require("micro-packed");
-const payment_js_1 = require("./payment.js");
-const psbt = require("./psbt.js"); // circular
-const script_js_1 = require("./script.js");
+const payment_ts_1 = require("./payment.js");
+const psbt = require("./psbt.js");
+const script_ts_1 = require("./script.js");
 const u = require("./utils.js");
-const utils_js_1 = require("./utils.js");
-const utxo_js_1 = require("./utxo.js"); // circular
+const utils_ts_1 = require("./utils.js");
 const EMPTY32 = new Uint8Array(32);
 const EMPTY_OUTPUT = {
     amount: 0xffffffffffffffffn,
     script: P.EMPTY,
 };
+const toVsize = (weight) => Math.ceil(weight / 4);
+exports.toVsize = toVsize;
 exports.PRECISION = 8;
 exports.DEFAULT_VERSION = 2;
 exports.DEFAULT_LOCKTIME = 0;
@@ -30,7 +34,7 @@ function cloneDeep(obj) {
     if (Array.isArray(obj))
         return obj.map((i) => cloneDeep(i));
     // slice of nodejs Buffer doesn't copy
-    else if ((0, utils_js_1.isBytes)(obj))
+    else if ((0, utils_ts_1.isBytes)(obj))
         return Uint8Array.from(obj);
     // immutable
     else if (['number', 'bigint', 'boolean', 'string', 'undefined'].includes(typeof obj))
@@ -68,7 +72,7 @@ var SigHash;
     SigHash[SigHash["SINGLE_ANYONECANPAY"] = 131] = "SINGLE_ANYONECANPAY";
 })(SigHash || (exports.SigHash = SigHash = {}));
 function getTaprootKeys(privKey, pubKey, internalKey, merkleRoot = P.EMPTY) {
-    if ((0, utils_js_1.equalBytes)(internalKey, pubKey)) {
+    if ((0, utils_ts_1.equalBytes)(internalKey, pubKey)) {
         privKey = u.taprootTweakPrivKey(privKey, merkleRoot);
         pubKey = u.pubSchnorr(privKey);
     }
@@ -166,6 +170,149 @@ function validateOpts(opts) {
     }
     return Object.freeze(_opts);
 }
+// NOTE: we cannot do this inside PSBTInput coder, because there is no index/txid at this point!
+function validateInput(i) {
+    if (i.nonWitnessUtxo && i.index !== undefined) {
+        const last = i.nonWitnessUtxo.outputs.length - 1;
+        if (i.index > last)
+            throw new Error(`validateInput: index(${i.index}) not in nonWitnessUtxo`);
+        const prevOut = i.nonWitnessUtxo.outputs[i.index];
+        if (i.witnessUtxo &&
+            (!(0, utils_ts_1.equalBytes)(i.witnessUtxo.script, prevOut.script) || i.witnessUtxo.amount !== prevOut.amount))
+            throw new Error('validateInput: witnessUtxo different from nonWitnessUtxo');
+        if (i.txid) {
+            const outputs = i.nonWitnessUtxo.outputs;
+            if (outputs.length - 1 < i.index)
+                throw new Error('nonWitnessUtxo: incorect output index');
+            // At this point, we are using previous tx output to create new input.
+            // Script safety checks are unnecessary:
+            // - User has no control over previous tx. If somebody send money in same tx
+            //   as unspendable output, we still want user able to spend money
+            // - We still want some checks to notify user about possible errors early
+            //   in case user wants to use wrong input by mistake
+            // - Worst case: tx will be rejected by nodes. Still better than disallowing user
+            //   to spend real input, no matter how broken it looks
+            const tx = Transaction.fromRaw(script_ts_1.RawTx.encode(i.nonWitnessUtxo), {
+                allowUnknownOutputs: true,
+                disableScriptCheck: true,
+                allowUnknownInputs: true,
+            });
+            const txid = base_1.hex.encode(i.txid);
+            // PSBTv2 vectors have non-final tx in inputs
+            if (tx.isFinal && tx.id !== txid)
+                throw new Error(`nonWitnessUtxo: wrong txid, exp=${txid} got=${tx.id}`);
+        }
+    }
+    return i;
+}
+// Normalizes input
+function getPrevOut(input) {
+    if (input.nonWitnessUtxo) {
+        if (input.index === undefined)
+            throw new Error('Unknown input index');
+        return input.nonWitnessUtxo.outputs[input.index];
+    }
+    else if (input.witnessUtxo)
+        return input.witnessUtxo;
+    else
+        throw new Error('Cannot find previous output info');
+}
+function normalizeInput(i, cur, allowedFields, disableScriptCheck = false, allowUnknown = false) {
+    let { nonWitnessUtxo, txid } = i;
+    // String support for common fields. We usually prefer Uint8Array to avoid errors
+    // like hex looking string accidentally passed, however, in case of nonWitnessUtxo
+    // it is better to expect string, since constructing this complex object will be
+    // difficult for user
+    if (typeof nonWitnessUtxo === 'string')
+        nonWitnessUtxo = base_1.hex.decode(nonWitnessUtxo);
+    if ((0, utils_ts_1.isBytes)(nonWitnessUtxo))
+        nonWitnessUtxo = script_ts_1.RawTx.decode(nonWitnessUtxo);
+    if (!('nonWitnessUtxo' in i) && nonWitnessUtxo === undefined)
+        nonWitnessUtxo = cur?.nonWitnessUtxo;
+    if (typeof txid === 'string')
+        txid = base_1.hex.decode(txid);
+    // TODO: if we have nonWitnessUtxo, we can extract txId from here
+    if (txid === undefined)
+        txid = cur?.txid;
+    let res = { ...cur, ...i, nonWitnessUtxo, txid };
+    if (!('nonWitnessUtxo' in i) && res.nonWitnessUtxo === undefined)
+        delete res.nonWitnessUtxo;
+    if (res.sequence === undefined)
+        res.sequence = exports.DEFAULT_SEQUENCE;
+    if (res.tapMerkleRoot === null)
+        delete res.tapMerkleRoot;
+    res = psbt.mergeKeyMap(psbt.PSBTInput, res, cur, allowedFields, allowUnknown);
+    psbt.PSBTInputCoder.encode(res); // Validates that everything is correct at this point
+    let prevOut;
+    if (res.nonWitnessUtxo && res.index !== undefined)
+        prevOut = res.nonWitnessUtxo.outputs[res.index];
+    else if (res.witnessUtxo)
+        prevOut = res.witnessUtxo;
+    if (prevOut && !disableScriptCheck)
+        (0, payment_ts_1.checkScript)(prevOut && prevOut.script, res.redeemScript, res.witnessScript);
+    return res;
+}
+function getInputType(input, allowLegacyWitnessUtxo = false) {
+    let txType = 'legacy';
+    let defaultSighash = SignatureHash.ALL;
+    const prevOut = getPrevOut(input);
+    const first = payment_ts_1.OutScript.decode(prevOut.script);
+    let type = first.type;
+    let cur = first;
+    const stack = [first];
+    if (first.type === 'tr') {
+        defaultSighash = SignatureHash.DEFAULT;
+        return {
+            txType: 'taproot',
+            type: 'tr',
+            last: first,
+            lastScript: prevOut.script,
+            defaultSighash,
+            sighash: input.sighashType || defaultSighash,
+        };
+    }
+    else {
+        if (first.type === 'wpkh' || first.type === 'wsh')
+            txType = 'segwit';
+        if (first.type === 'sh') {
+            if (!input.redeemScript)
+                throw new Error('inputType: sh without redeemScript');
+            let child = payment_ts_1.OutScript.decode(input.redeemScript);
+            if (child.type === 'wpkh' || child.type === 'wsh')
+                txType = 'segwit';
+            stack.push(child);
+            cur = child;
+            type += `-${child.type}`;
+        }
+        // wsh can be inside sh
+        if (cur.type === 'wsh') {
+            if (!input.witnessScript)
+                throw new Error('inputType: wsh without witnessScript');
+            let child = payment_ts_1.OutScript.decode(input.witnessScript);
+            if (child.type === 'wsh')
+                txType = 'segwit';
+            stack.push(child);
+            cur = child;
+            type += `-${child.type}`;
+        }
+        const last = stack[stack.length - 1];
+        if (last.type === 'sh' || last.type === 'wsh')
+            throw new Error('inputType: sh/wsh cannot be terminal type');
+        const lastScript = payment_ts_1.OutScript.encode(last);
+        const res = {
+            type,
+            txType,
+            last,
+            lastScript,
+            defaultSighash,
+            sighash: input.sighashType || defaultSighash,
+        };
+        if (txType === 'legacy' && !allowLegacyWitnessUtxo && !input.nonWitnessUtxo) {
+            throw new Error(`Transaction/sign: legacy input without nonWitnessUtxo, can result in attack that forces paying higher fees. Pass allowLegacyWitnessUtxo=true, if you sure`);
+        }
+        return res;
+    }
+}
 class Transaction {
     constructor(opts = {}) {
         this.global = {};
@@ -179,7 +326,7 @@ class Transaction {
     }
     // Import
     static fromRaw(raw, opts = {}) {
-        const parsed = script_js_1.RawTx.decode(raw);
+        const parsed = script_ts_1.RawTx.decode(raw);
         const tx = new Transaction({ ...opts, version: parsed.version, lockTime: parsed.lockTime });
         for (const o of parsed.outputs)
             tx.addOutput(o);
@@ -215,7 +362,7 @@ class Transaction {
         const tx = new Transaction({ ...opts, version, lockTime, PSBTVersion });
         // We need slice here, because otherwise
         const inputCount = PSBTVersion === 0 ? unsigned?.inputs.length : parsed.global.inputCount;
-        tx.inputs = parsed.inputs.slice(0, inputCount).map((i, j) => ({
+        tx.inputs = parsed.inputs.slice(0, inputCount).map((i, j) => validateInput({
             finalScriptSig: P.EMPTY,
             ...parsed.global.unsignedTx?.inputs[j],
             ...i,
@@ -238,7 +385,7 @@ class Transaction {
         //     'PSBT version=0 export for transaction without inputs disabled, please use version=2. Please check `toPSBT` method for explanation.'
         //   );
         // }
-        const inputs = this.inputs.map((i) => psbt.cleanPSBTFields(PSBTVersion, psbt.PSBTInput, i));
+        const inputs = this.inputs.map((i) => validateInput(psbt.cleanPSBTFields(PSBTVersion, psbt.PSBTInput, i)));
         for (const inp of inputs) {
             // Don't serialize empty fields
             if (inp.partialSig && !inp.partialSig.length)
@@ -257,7 +404,7 @@ class Transaction {
             - Parsing of PSBTv0 depends on unsignedTx (it looks for input count here)
             - BIP-174 requires old serialization format (without witnesses) inside global, which solves this
             */
-            global.unsignedTx = script_js_1.RawOldTx.decode(script_js_1.RawOldTx.encode({
+            global.unsignedTx = script_ts_1.RawOldTx.decode(script_ts_1.RawOldTx.encode({
                 version: this.version,
                 lockTime: this.lockTime,
                 inputs: this.inputs.map(inputBeforeSign).map((i) => ({
@@ -402,25 +549,25 @@ class Transaction {
         let out = 32;
         // Outputs
         const outputs = this.outputs.map(outputBeforeSign);
-        out += 4 * script_js_1.CompactSizeLen.encode(this.outputs.length).length;
+        out += 4 * script_ts_1.CompactSizeLen.encode(this.outputs.length).length;
         for (const o of outputs)
-            out += 32 + 4 * script_js_1.VarBytes.encode(o.script).length;
+            out += 32 + 4 * script_ts_1.VarBytes.encode(o.script).length;
         // Inputs
         if (this.hasWitnesses)
             out += 2;
-        out += 4 * script_js_1.CompactSizeLen.encode(this.inputs.length).length;
+        out += 4 * script_ts_1.CompactSizeLen.encode(this.inputs.length).length;
         for (const i of this.inputs) {
-            out += 160 + 4 * script_js_1.VarBytes.encode(i.finalScriptSig || P.EMPTY).length;
+            out += 160 + 4 * script_ts_1.VarBytes.encode(i.finalScriptSig || P.EMPTY).length;
             if (this.hasWitnesses && i.finalScriptWitness)
-                out += script_js_1.RawWitness.encode(i.finalScriptWitness).length;
+                out += script_ts_1.RawWitness.encode(i.finalScriptWitness).length;
         }
         return out;
     }
     get vsize() {
-        return (0, utxo_js_1.toVsize)(this.weight);
+        return (0, exports.toVsize)(this.weight);
     }
     toBytes(withScriptSig = false, withWitness = false) {
-        return script_js_1.RawTx.encode({
+        return script_ts_1.RawTx.encode({
             version: this.version,
             lockTime: this.lockTime,
             inputs: this.inputs.map(inputBeforeSign).map((i) => ({
@@ -464,7 +611,7 @@ class Transaction {
     addInput(input, _ignoreSignStatus = false) {
         if (!_ignoreSignStatus && !this.signStatus().addInput)
             throw new Error('Tx has signed inputs, cannot add new one');
-        this.inputs.push((0, utxo_js_1.normalizeInput)(input, undefined, undefined, this.opts.disableScriptCheck));
+        this.inputs.push(normalizeInput(input, undefined, undefined, this.opts.disableScriptCheck));
         return this.inputs.length - 1;
     }
     updateInput(idx, input, _ignoreSignStatus = false) {
@@ -475,7 +622,7 @@ class Transaction {
             if (!status.addInput || status.inputs.includes(idx))
                 allowedFields = psbt.PSBTInputUnsignedKeys;
         }
-        this.inputs[idx] = (0, utxo_js_1.normalizeInput)(input, this.inputs[idx], allowedFields, this.opts.disableScriptCheck, this.opts.allowUnknown);
+        this.inputs[idx] = normalizeInput(input, this.inputs[idx], allowedFields, this.opts.disableScriptCheck, this.opts.allowUnknown);
     }
     // Output stuff
     checkOutputIdx(idx) {
@@ -486,11 +633,11 @@ class Transaction {
         this.checkOutputIdx(idx);
         return cloneDeep(this.outputs[idx]);
     }
-    getOutputAddress(idx, network = utils_js_1.NETWORK) {
+    getOutputAddress(idx, network = utils_ts_1.NETWORK) {
         const out = this.getOutput(idx);
         if (!out.script)
             return;
-        return (0, payment_js_1.Address)(network).encode(payment_js_1.OutScript.decode(out.script));
+        return (0, payment_ts_1.Address)(network).encode(payment_ts_1.OutScript.decode(out.script));
     }
     get outputsLength() {
         return this.outputs.length;
@@ -512,11 +659,11 @@ class Transaction {
         psbt.PSBTOutputCoder.encode(res);
         if (res.script &&
             !this.opts.allowUnknownOutputs &&
-            payment_js_1.OutScript.decode(res.script).type === 'unknown') {
+            payment_ts_1.OutScript.decode(res.script).type === 'unknown') {
             throw new Error('Transaction/output: unknown output script type, there is a chance that input is unspendable. Pass allowUnknownOutputs=true, if you sure');
         }
         if (!this.opts.disableScriptCheck)
-            (0, payment_js_1.checkScript)(res.script, res.redeemScript, res.witnessScript);
+            (0, payment_ts_1.checkScript)(res.script, res.redeemScript, res.witnessScript);
         return res;
     }
     addOutput(o, _ignoreSignStatus = false) {
@@ -535,14 +682,14 @@ class Transaction {
         }
         this.outputs[idx] = this.normalizeOutput(output, this.outputs[idx], allowedFields);
     }
-    addOutputAddress(address, amount, network = utils_js_1.NETWORK) {
-        return this.addOutput({ script: payment_js_1.OutScript.encode((0, payment_js_1.Address)(network).decode(address)), amount });
+    addOutputAddress(address, amount, network = utils_ts_1.NETWORK) {
+        return this.addOutput({ script: payment_ts_1.OutScript.encode((0, payment_ts_1.Address)(network).decode(address)), amount });
     }
     // Utils
     get fee() {
         let res = 0n;
         for (const i of this.inputs) {
-            const prevOut = (0, utxo_js_1.getPrevOut)(i);
+            const prevOut = getPrevOut(i);
             if (!prevOut)
                 throw new Error('Empty input amount');
             res += prevOut.amount;
@@ -562,7 +709,7 @@ class Transaction {
             throw new Error(`Invalid input idx=${idx}`);
         if ((isSingle && idx >= this.outputs.length) || idx >= this.inputs.length)
             return P.U256BE.encode(1n);
-        prevOutScript = script_js_1.Script.encode(script_js_1.Script.decode(prevOutScript).filter((i) => i !== 'CODESEPARATOR'));
+        prevOutScript = script_ts_1.Script.encode(script_ts_1.Script.decode(prevOutScript).filter((i) => i !== 'CODESEPARATOR'));
         let inputs = this.inputs
             .map(inputBeforeSign)
             .map((input, inputIdx) => ({
@@ -583,7 +730,7 @@ class Transaction {
         else if (isSingle) {
             outputs = outputs.slice(0, idx).fill(EMPTY_OUTPUT).concat([outputs[idx]]);
         }
-        const tmpTx = script_js_1.RawTx.encode({
+        const tmpTx = script_ts_1.RawTx.encode({
             lockTime: this.lockTime,
             version: this.version,
             segwitFlag: false,
@@ -604,12 +751,12 @@ class Transaction {
         if (!isAny && !isSingle && !isNone)
             sequenceHash = u.sha256x2(...inputs.map((i) => P.U32LE.encode(i.sequence)));
         if (!isSingle && !isNone) {
-            outputHash = u.sha256x2(...outputs.map(script_js_1.RawOutput.encode));
+            outputHash = u.sha256x2(...outputs.map(script_ts_1.RawOutput.encode));
         }
         else if (isSingle && idx < outputs.length)
-            outputHash = u.sha256x2(script_js_1.RawOutput.encode(outputs[idx]));
+            outputHash = u.sha256x2(script_ts_1.RawOutput.encode(outputs[idx]));
         const input = inputs[idx];
-        return u.sha256x2(P.I32LE.encode(this.version), inputHash, sequenceHash, P.bytes(32, true).encode(input.txid), P.U32LE.encode(input.index), script_js_1.VarBytes.encode(prevOutScript), P.U64LE.encode(amount), P.U32LE.encode(input.sequence), outputHash, P.U32LE.encode(this.lockTime), P.U32LE.encode(hashType));
+        return u.sha256x2(P.I32LE.encode(this.version), inputHash, sequenceHash, P.bytes(32, true).encode(input.txid), P.U32LE.encode(input.index), script_ts_1.VarBytes.encode(prevOutScript), P.U64LE.encode(amount), P.U32LE.encode(input.sequence), outputHash, P.U32LE.encode(this.lockTime), P.U32LE.encode(hashType));
     }
     preimageWitnessV1(idx, prevOutScript, hashType, amount, codeSeparator = -1, leafScript, leafVer = 0xc0, annex) {
         if (!Array.isArray(amount) || this.inputs.length !== amount.length)
@@ -630,36 +777,36 @@ class Transaction {
             out.push(...[
                 inputs.map(TxHashIdx.encode),
                 amount.map(P.U64LE.encode),
-                prevOutScript.map(script_js_1.VarBytes.encode),
+                prevOutScript.map(script_ts_1.VarBytes.encode),
                 inputs.map((i) => P.U32LE.encode(i.sequence)),
-            ].map((i) => u.sha256((0, utils_js_1.concatBytes)(...i))));
+            ].map((i) => u.sha256((0, utils_ts_1.concatBytes)(...i))));
         }
         if (outType === SignatureHash.ALL) {
-            out.push(u.sha256((0, utils_js_1.concatBytes)(...outputs.map(script_js_1.RawOutput.encode))));
+            out.push(u.sha256((0, utils_ts_1.concatBytes)(...outputs.map(script_ts_1.RawOutput.encode))));
         }
         const spendType = (annex ? 1 : 0) | (leafScript ? 2 : 0);
         out.push(new Uint8Array([spendType]));
         if (inType === SignatureHash.ANYONECANPAY) {
             const inp = inputs[idx];
-            out.push(TxHashIdx.encode(inp), P.U64LE.encode(amount[idx]), script_js_1.VarBytes.encode(prevOutScript[idx]), P.U32LE.encode(inp.sequence));
+            out.push(TxHashIdx.encode(inp), P.U64LE.encode(amount[idx]), script_ts_1.VarBytes.encode(prevOutScript[idx]), P.U32LE.encode(inp.sequence));
         }
         else
             out.push(P.U32LE.encode(idx));
         if (spendType & 1)
-            out.push(u.sha256(script_js_1.VarBytes.encode(annex || P.EMPTY)));
+            out.push(u.sha256(script_ts_1.VarBytes.encode(annex || P.EMPTY)));
         if (outType === SignatureHash.SINGLE)
-            out.push(idx < outputs.length ? u.sha256(script_js_1.RawOutput.encode(outputs[idx])) : EMPTY32);
+            out.push(idx < outputs.length ? u.sha256(script_ts_1.RawOutput.encode(outputs[idx])) : EMPTY32);
         if (leafScript)
-            out.push((0, payment_js_1.tapLeafHash)(leafScript, leafVer), P.U8.encode(0), P.I32LE.encode(codeSeparator));
+            out.push((0, payment_ts_1.tapLeafHash)(leafScript, leafVer), P.U8.encode(0), P.I32LE.encode(codeSeparator));
         return u.tagSchnorr('TapSighash', ...out);
     }
     // Signer can be privateKey OR instance of bip32 HD stuff
     signIdx(privateKey, idx, allowedSighash, _auxRand) {
         this.checkInputIdx(idx);
         const input = this.inputs[idx];
-        const inputType = (0, utxo_js_1.getInputType)(input, this.opts.allowLegacyWitnessUtxo);
+        const inputType = getInputType(input, this.opts.allowLegacyWitnessUtxo);
         // Handle BIP32 HDKey
-        if (!(0, utils_js_1.isBytes)(privateKey)) {
+        if (!(0, utils_ts_1.isBytes)(privateKey)) {
             if (!input.bip32Derivation || !input.bip32Derivation.length)
                 throw new Error('bip32Derivation: empty');
             const signers = input.bip32Derivation
@@ -668,7 +815,7 @@ class Transaction {
                 let s = privateKey;
                 for (const i of path)
                     s = s.deriveChild(i);
-                if (!(0, utils_js_1.equalBytes)(s.publicKey, pubKey))
+                if (!(0, utils_ts_1.equalBytes)(s.publicKey, pubKey))
                     throw new Error('bip32Derivation: wrong pubKey');
                 if (!s.privateKey)
                     throw new Error('bip32Derivation: no privateKey');
@@ -702,9 +849,9 @@ class Transaction {
         }
         // Actual signing
         // Taproot
-        const prevOut = (0, utxo_js_1.getPrevOut)(input);
+        const prevOut = getPrevOut(input);
         if (inputType.txType === 'taproot') {
-            const prevOuts = this.inputs.map(utxo_js_1.getPrevOut);
+            const prevOuts = this.inputs.map(getPrevOut);
             const prevOutScript = prevOuts.map((i) => i.script);
             const amount = prevOuts.map((i) => i.amount);
             let signed = false;
@@ -717,9 +864,9 @@ class Transaction {
                 // priv key to be provided
                 const { pubKey, privKey } = getTaprootKeys(privateKey, schnorrPub, input.tapInternalKey, merkleRoot);
                 const [taprootPubKey, _] = u.taprootTweakPubkey(input.tapInternalKey, merkleRoot);
-                if ((0, utils_js_1.equalBytes)(taprootPubKey, pubKey)) {
+                if ((0, utils_ts_1.equalBytes)(taprootPubKey, pubKey)) {
                     const hash = this.preimageWitnessV1(idx, prevOutScript, sighash, amount);
-                    const sig = (0, utils_js_1.concatBytes)(u.signSchnorr(hash, privKey, _auxRand), sighash !== SignatureHash.DEFAULT ? new Uint8Array([sighash]) : P.EMPTY);
+                    const sig = (0, utils_ts_1.concatBytes)(u.signSchnorr(hash, privKey, _auxRand), sighash !== SignatureHash.DEFAULT ? new Uint8Array([sighash]) : P.EMPTY);
                     this.updateInput(idx, { tapKeySig: sig }, true);
                     signed = true;
                 }
@@ -728,16 +875,16 @@ class Transaction {
                 input.tapScriptSig = input.tapScriptSig || [];
                 for (const [_, _script] of input.tapLeafScript) {
                     const script = _script.subarray(0, -1);
-                    const scriptDecoded = script_js_1.Script.decode(script);
+                    const scriptDecoded = script_ts_1.Script.decode(script);
                     const ver = _script[_script.length - 1];
-                    const hash = (0, payment_js_1.tapLeafHash)(script, ver);
+                    const hash = (0, payment_ts_1.tapLeafHash)(script, ver);
                     // NOTE: no need to tweak internal key here, since we don't support nested p2tr
-                    const pos = scriptDecoded.findIndex((i) => (0, utils_js_1.isBytes)(i) && (0, utils_js_1.equalBytes)(i, schnorrPub));
+                    const pos = scriptDecoded.findIndex((i) => (0, utils_ts_1.isBytes)(i) && (0, utils_ts_1.equalBytes)(i, schnorrPub));
                     // Skip if there is no public key in tapLeafScript
                     if (pos === -1)
                         continue;
                     const msg = this.preimageWitnessV1(idx, prevOutScript, sighash, amount, undefined, script, ver);
-                    const sig = (0, utils_js_1.concatBytes)(u.signSchnorr(msg, privateKey, _auxRand), sighash !== SignatureHash.DEFAULT ? new Uint8Array([sighash]) : P.EMPTY);
+                    const sig = (0, utils_ts_1.concatBytes)(u.signSchnorr(msg, privateKey, _auxRand), sighash !== SignatureHash.DEFAULT ? new Uint8Array([sighash]) : P.EMPTY);
                     this.updateInput(idx, { tapScriptSig: [[{ pubKey: schnorrPub, leafHash: hash }, sig]] }, true);
                     signed = true;
                 }
@@ -753,8 +900,8 @@ class Transaction {
             // Check if script has public key or its has inside
             let hasPubkey = false;
             const pubKeyHash = u.hash160(pubKey);
-            for (const i of script_js_1.Script.decode(inputType.lastScript)) {
-                if ((0, utils_js_1.isBytes)(i) && ((0, utils_js_1.equalBytes)(i, pubKey) || (0, utils_js_1.equalBytes)(i, pubKeyHash)))
+            for (const i of script_ts_1.Script.decode(inputType.lastScript)) {
+                if ((0, utils_ts_1.isBytes)(i) && ((0, utils_ts_1.equalBytes)(i, pubKey) || (0, utils_ts_1.equalBytes)(i, pubKeyHash)))
                     hasPubkey = true;
             }
             if (!hasPubkey)
@@ -767,14 +914,14 @@ class Transaction {
                 let script = inputType.lastScript;
                 // If wpkh OR sh-wpkh, wsh-wpkh is impossible, so looks ok
                 if (inputType.last.type === 'wpkh')
-                    script = payment_js_1.OutScript.encode({ type: 'pkh', hash: inputType.last.hash });
+                    script = payment_ts_1.OutScript.encode({ type: 'pkh', hash: inputType.last.hash });
                 hash = this.preimageWitnessV0(idx, script, sighash, prevOut.amount);
             }
             else
                 throw new Error(`Transaction/sign: unknown tx type: ${inputType.txType}`);
             const sig = u.signECDSA(hash, privateKey, this.opts.lowR);
             this.updateInput(idx, {
-                partialSig: [[pubKey, (0, utils_js_1.concatBytes)(sig, new Uint8Array([sighash]))]],
+                partialSig: [[pubKey, (0, utils_ts_1.concatBytes)(sig, new Uint8Array([sighash]))]],
             }, true);
         }
         return true;
@@ -804,7 +951,7 @@ class Transaction {
         if (this.fee < 0n)
             throw new Error('Outputs spends more than inputs amount');
         const input = this.inputs[idx];
-        const inputType = (0, utxo_js_1.getInputType)(input, this.opts.allowLegacyWitnessUtxo);
+        const inputType = getInputType(input, this.opts.allowLegacyWitnessUtxo);
         // Taproot finalize
         if (inputType.txType === 'taproot') {
             if (input.tapKeySig)
@@ -817,16 +964,16 @@ class Transaction {
                     // Last byte is version
                     const script = _script.slice(0, -1);
                     const ver = _script[_script.length - 1];
-                    const outScript = payment_js_1.OutScript.decode(script);
-                    const hash = (0, payment_js_1.tapLeafHash)(script, ver);
-                    const scriptSig = input.tapScriptSig.filter((i) => (0, utils_js_1.equalBytes)(i[0].leafHash, hash));
+                    const outScript = payment_ts_1.OutScript.decode(script);
+                    const hash = (0, payment_ts_1.tapLeafHash)(script, ver);
+                    const scriptSig = input.tapScriptSig.filter((i) => (0, utils_ts_1.equalBytes)(i[0].leafHash, hash));
                     let signatures = [];
                     if (outScript.type === 'tr_ms') {
                         const m = outScript.m;
                         const pubkeys = outScript.pubkeys;
                         let added = 0;
                         for (const pub of pubkeys) {
-                            const sigIdx = scriptSig.findIndex((i) => (0, utils_js_1.equalBytes)(i[0].pubKey, pub));
+                            const sigIdx = scriptSig.findIndex((i) => (0, utils_ts_1.equalBytes)(i[0].pubKey, pub));
                             // Should have exact amount of signatures (more -- will fail)
                             if (added === m || sigIdx === -1) {
                                 signatures.push(P.EMPTY);
@@ -841,7 +988,7 @@ class Transaction {
                     }
                     else if (outScript.type === 'tr_ns') {
                         for (const pub of outScript.pubkeys) {
-                            const sigIdx = scriptSig.findIndex((i) => (0, utils_js_1.equalBytes)(i[0].pubKey, pub));
+                            const sigIdx = scriptSig.findIndex((i) => (0, utils_ts_1.equalBytes)(i[0].pubKey, pub));
                             if (sigIdx === -1)
                                 continue;
                             signatures.push(scriptSig[sigIdx][1]);
@@ -851,10 +998,10 @@ class Transaction {
                     }
                     else if (outScript.type === 'unknown' && this.opts.allowUnknownInputs) {
                         // Trying our best to sign what we can
-                        const scriptDecoded = script_js_1.Script.decode(script);
+                        const scriptDecoded = script_ts_1.Script.decode(script);
                         signatures = scriptSig
                             .map(([{ pubKey }, signature]) => {
-                            const pos = scriptDecoded.findIndex((i) => (0, utils_js_1.isBytes)(i) && (0, utils_js_1.equalBytes)(i, pubKey));
+                            const pos = scriptDecoded.findIndex((i) => (0, utils_ts_1.isBytes)(i) && (0, utils_ts_1.equalBytes)(i, pubKey));
                             if (pos === -1)
                                 throw new Error('finalize/taproot: cannot find position of pubkey in script');
                             return { signature, pos };
@@ -871,7 +1018,7 @@ class Transaction {
                             for (const c of custom) {
                                 if (!c.finalizeTaproot)
                                     continue;
-                                const scriptDecoded = script_js_1.Script.decode(script);
+                                const scriptDecoded = script_ts_1.Script.decode(script);
                                 const csEncoded = c.encode(scriptDecoded);
                                 if (csEncoded === undefined)
                                     continue;
@@ -913,7 +1060,7 @@ class Transaction {
             let signatures = [];
             // partial: [pubkey, sign]
             for (const pub of pubkeys) {
-                const sign = input.partialSig.find((s) => (0, utils_js_1.equalBytes)(pub, s[0]));
+                const sign = input.partialSig.find((s) => (0, utils_ts_1.equalBytes)(pub, s[0]));
                 if (!sign)
                     continue;
                 signatures.push(sign[1]);
@@ -922,13 +1069,13 @@ class Transaction {
             if (signatures.length !== m) {
                 throw new Error(`Multisig: wrong signatures count, m=${m} n=${pubkeys.length} signatures=${signatures.length}`);
             }
-            inputScript = script_js_1.Script.encode([0, ...signatures]);
+            inputScript = script_ts_1.Script.encode([0, ...signatures]);
         }
         else if (inputType.last.type === 'pk') {
-            inputScript = script_js_1.Script.encode([input.partialSig[0][1]]);
+            inputScript = script_ts_1.Script.encode([input.partialSig[0][1]]);
         }
         else if (inputType.last.type === 'pkh') {
-            inputScript = script_js_1.Script.encode([input.partialSig[0][1], input.partialSig[0][0]]);
+            inputScript = script_ts_1.Script.encode([input.partialSig[0][1], input.partialSig[0][0]]);
         }
         else if (inputType.last.type === 'wpkh') {
             inputScript = P.EMPTY;
@@ -941,10 +1088,10 @@ class Transaction {
         if (inputType.type.includes('wsh-')) {
             // P2WSH
             if (inputScript.length && inputType.lastScript.length) {
-                witness = script_js_1.Script.decode(inputScript).map((i) => {
+                witness = script_ts_1.Script.decode(inputScript).map((i) => {
                     if (i === 0)
                         return P.EMPTY;
-                    if ((0, utils_js_1.isBytes)(i))
+                    if ((0, utils_ts_1.isBytes)(i))
                         return i;
                     throw new Error(`Wrong witness op=${i}`);
                 });
@@ -954,10 +1101,10 @@ class Transaction {
         if (inputType.txType === 'segwit')
             finalScriptWitness = witness;
         if (inputType.type.startsWith('sh-wsh-')) {
-            finalScriptSig = script_js_1.Script.encode([script_js_1.Script.encode([0, u.sha256(inputType.lastScript)])]);
+            finalScriptSig = script_ts_1.Script.encode([script_ts_1.Script.encode([0, u.sha256(inputType.lastScript)])]);
         }
         else if (inputType.type.startsWith('sh-')) {
-            finalScriptSig = script_js_1.Script.encode([...script_js_1.Script.decode(inputScript), inputType.lastScript]);
+            finalScriptSig = script_ts_1.Script.encode([...script_ts_1.Script.decode(inputScript), inputType.lastScript]);
         }
         else if (inputType.type.startsWith('wsh-')) {
         }
@@ -995,11 +1142,11 @@ class Transaction {
                 throw new Error(`Transaction/combine: different ${k} length this=${this[k].length} other=${other[k].length}`);
             }
         }
-        const thisUnsigned = this.global.unsignedTx ? script_js_1.RawOldTx.encode(this.global.unsignedTx) : P.EMPTY;
+        const thisUnsigned = this.global.unsignedTx ? script_ts_1.RawOldTx.encode(this.global.unsignedTx) : P.EMPTY;
         const otherUnsigned = other.global.unsignedTx
-            ? script_js_1.RawOldTx.encode(other.global.unsignedTx)
+            ? script_ts_1.RawOldTx.encode(other.global.unsignedTx)
             : P.EMPTY;
-        if (!(0, utils_js_1.equalBytes)(thisUnsigned, otherUnsigned))
+        if (!(0, utils_ts_1.equalBytes)(thisUnsigned, otherUnsigned))
             throw new Error(`Transaction/combine: different unsigned tx`);
         this.global = psbt.mergeKeyMap(psbt.PSBTGlobal, this.global, other.global, undefined, this.opts.allowUnknown);
         for (let i = 0; i < this.inputs.length; i++)