utxo-lib 1.0.1

package/dist/src/transaction_builder.js

@@ -0,0 +1,1084 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionBuilder = void 0;
+const types = require("bitcoinjs-lib/src/types");
+const _1 = require("./");
+const bufferutils = require("bitcoinjs-lib/src/bufferutils");
+const classify = require("./classify");
+const _2 = require("./");
+const _3 = require("./");
+const _4 = require("./");
+const _5 = require("./");
+const _6 = require("./");
+const _7 = require("./");
+const _8 = require("./");
+const noble_ecc_1 = require("./noble_ecc");
+const typeforce = require('typeforce');
+const tfFullSigner = (obj) => {
+    return typeforce.Buffer(obj.publicKey) && typeof obj.sign === 'function' && typeof obj.signSchnorr === 'function';
+};
+const SCRIPT_TYPES = classify.types;
+const PREVOUT_TYPES = new Set([
+    // Raw
+    'p2pkh',
+    'p2pk',
+    'p2wpkh',
+    'p2ms',
+    // P2SH wrapped
+    'p2sh-p2pkh',
+    'p2sh-p2pk',
+    'p2sh-p2wpkh',
+    'p2sh-p2ms',
+    // P2WSH wrapped
+    'p2wsh-p2pkh',
+    'p2wsh-p2pk',
+    'p2wsh-p2ms',
+    // P2SH-P2WSH wrapper
+    'p2sh-p2wsh-p2pkh',
+    'p2sh-p2wsh-p2pk',
+    'p2sh-p2wsh-p2ms',
+    // P2TR KeyPath
+    'p2tr',
+    // P2TR ScriptPath
+    'p2tr-p2ns',
+]);
+function tfMessage(type, value, message) {
+    try {
+        typeforce(type, value);
+    }
+    catch (err) {
+        throw new Error(message);
+    }
+}
+function txIsString(tx) {
+    return typeof tx === 'string' || tx instanceof String;
+}
+function txIsTransaction(tx) {
+    return tx instanceof _8.Transaction;
+}
+class TransactionBuilder {
+    // WARNING: maximumFeeRate is __NOT__ to be relied on,
+    //          it's just another potential safety mechanism (safety in-depth)
+    constructor(network = _3.networks.bitcoin, maximumFeeRate = 2500) {
+        this.network = network;
+        this.maximumFeeRate = maximumFeeRate;
+        this.__PREV_TX_SET = {};
+        this.__INPUTS = [];
+        this.__TX = new _8.Transaction();
+        this.__TX.version = 2;
+        this.__USE_LOW_R = false;
+        console.warn('Deprecation Warning: TransactionBuilder will be removed in the future. ' +
+            '(v6.x.x or later) Please use the Psbt class instead. Examples of usage ' +
+            'are available in the transactions-psbt.js integration test file on our ' +
+            'Github. A high level explanation is available in the psbt.ts and psbt.js ' +
+            'files as well.');
+    }
+    static fromTransaction(transaction, network, prevOutputs) {
+        const txb = new TransactionBuilder(network);
+        // Copy transaction fields
+        txb.setVersion(transaction.version);
+        txb.setLockTime(transaction.locktime);
+        // Copy outputs (done first to avoid signature invalidation)
+        transaction.outs.forEach((txOut) => {
+            txb.addOutput(txOut.script, txOut.value);
+        });
+        // Copy inputs
+        transaction.ins.forEach((txIn) => {
+            txb.__addInputUnsafe(txIn.hash, txIn.index, {
+                sequence: txIn.sequence,
+                script: txIn.script,
+                witness: txIn.witness,
+            });
+        });
+        // fix some things not possible through the public API
+        txb.__INPUTS.forEach((input, i) => {
+            fixMultisigOrder(input, transaction, i, prevOutputs);
+        });
+        return txb;
+    }
+    setLowR(setting) {
+        typeforce(typeforce.maybe(typeforce.Boolean), setting);
+        if (setting === undefined) {
+            setting = true;
+        }
+        this.__USE_LOW_R = setting;
+        return setting;
+    }
+    setLockTime(locktime) {
+        typeforce(types.UInt32, locktime);
+        // if any signatures exist, throw
+        if (this.__INPUTS.some((input) => {
+            if (!input.signatures)
+                return false;
+            return input.signatures.some((s) => s !== undefined);
+        })) {
+            throw new Error('No, this would invalidate signatures');
+        }
+        this.__TX.locktime = locktime;
+    }
+    setVersion(version) {
+        typeforce(types.UInt32, version);
+        // XXX: this might eventually become more complex depending on what the versions represent
+        this.__TX.version = version;
+    }
+    addInput(txHash, vout, sequence, prevOutScript, value) {
+        if (!this.__canModifyInputs()) {
+            throw new Error('No, this would invalidate signatures');
+        }
+        // is it a hex string?
+        if (txIsString(txHash)) {
+            // transaction hashs's are displayed in reverse order, un-reverse it
+            txHash = bufferutils.reverseBuffer(Buffer.from(txHash, 'hex'));
+            // is it a Transaction object?
+        }
+        else if (txIsTransaction(txHash)) {
+            const txOut = txHash.outs[vout];
+            prevOutScript = txOut.script;
+            value = txOut.value;
+            txHash = txHash.getHash(false);
+        }
+        return this.__addInputUnsafe(txHash, vout, {
+            sequence,
+            prevOutScript,
+            value,
+        });
+    }
+    addOutput(scriptPubKey, value) {
+        if (!this.__canModifyOutputs()) {
+            throw new Error('No, this would invalidate signatures');
+        }
+        // Attempt to get a script if it's a base58 or bech32 address string
+        if (typeof scriptPubKey === 'string') {
+            scriptPubKey = _1.address.toOutputScript(scriptPubKey, this.network);
+        }
+        return this.__TX.addOutput(scriptPubKey, value);
+    }
+    build() {
+        return this.__build(false);
+    }
+    buildIncomplete() {
+        return this.__build(true);
+    }
+    sign(signParams, keyPair, redeemScript, hashType, witnessValue, witnessScript, controlBlock, annex) {
+        trySign(getSigningData(this.network, this.__INPUTS, this.__needsOutputs.bind(this), this.__TX, signParams, keyPair, redeemScript, hashType, witnessValue, witnessScript, controlBlock, annex, this.__USE_LOW_R));
+    }
+    __addInputUnsafe(txHash, vout, options) {
+        if (_8.Transaction.isCoinbaseHash(txHash)) {
+            throw new Error('coinbase inputs not supported');
+        }
+        const prevTxOut = txHash.toString('hex') + ':' + vout;
+        if (this.__PREV_TX_SET[prevTxOut] !== undefined)
+            throw new Error('Duplicate TxOut: ' + prevTxOut);
+        let input = {};
+        // derive what we can from the scriptSig
+        if (options.script !== undefined || options.witness !== undefined) {
+            input = expandInput(options.script, options.witness);
+        }
+        // if an input value was given, retain it
+        if (options.value !== undefined) {
+            input.value = options.value;
+        }
+        // derive what we can from the previous transactions output script
+        if (!input.prevOutScript && options.prevOutScript) {
+            let prevOutType;
+            if (!input.pubkeys && !input.signatures) {
+                const expanded = expandOutput(options.prevOutScript);
+                if (expanded.pubkeys) {
+                    input.pubkeys = expanded.pubkeys;
+                    input.signatures = expanded.signatures;
+                }
+                prevOutType = expanded.type;
+            }
+            input.prevOutScript = options.prevOutScript;
+            input.prevOutType = prevOutType || classify.output(options.prevOutScript);
+        }
+        const vin = this.__TX.addInput(txHash, vout, options.sequence, options.scriptSig);
+        this.__INPUTS[vin] = input;
+        this.__PREV_TX_SET[prevTxOut] = true;
+        return vin;
+    }
+    __build(allowIncomplete) {
+        if (!allowIncomplete) {
+            if (!this.__TX.ins.length)
+                throw new Error('Transaction has no inputs');
+            if (!this.__TX.outs.length)
+                throw new Error('Transaction has no outputs');
+        }
+        const tx = this.__TX.clone();
+        // create script signatures from inputs
+        this.__INPUTS.forEach((input, i) => {
+            if (!input.prevOutType && !allowIncomplete)
+                throw new Error('Transaction is not complete');
+            const result = build(input.prevOutType, input, allowIncomplete);
+            if (!result) {
+                if (!allowIncomplete && input.prevOutType === SCRIPT_TYPES.NONSTANDARD)
+                    throw new Error('Unknown input type');
+                if (!allowIncomplete)
+                    throw new Error('Not enough information');
+                return;
+            }
+            if (result.input) {
+                tx.setInputScript(i, result.input);
+            }
+            tx.setWitness(i, result.witness);
+        });
+        if (!allowIncomplete) {
+            // do not rely on this, its merely a last resort
+            if (this.__overMaximumFees(tx.virtualSize())) {
+                throw new Error('Transaction has absurd fees');
+            }
+        }
+        return tx;
+    }
+    __canModifyInputs() {
+        return this.__INPUTS.every((input) => {
+            if (!input.signatures)
+                return true;
+            return input.signatures.every((signature) => {
+                if (!signature)
+                    return true;
+                const hashType = signatureHashType(signature);
+                // if SIGHASH_ANYONECANPAY is set, signatures would not
+                // be invalidated by more inputs
+                return (hashType & _8.Transaction.SIGHASH_ANYONECANPAY) !== 0;
+            });
+        });
+    }
+    __needsOutputs(signingHashType) {
+        if (signingHashType === _8.Transaction.SIGHASH_ALL || signingHashType === _8.Transaction.SIGHASH_DEFAULT) {
+            return this.__TX.outs.length === 0;
+        }
+        // if inputs are being signed with SIGHASH_NONE, we don't strictly need outputs
+        // .build() will fail, but .buildIncomplete() is OK
+        return (this.__TX.outs.length === 0 &&
+            this.__INPUTS.some((input) => {
+                if (!input.signatures)
+                    return false;
+                return input.signatures.some((signature) => {
+                    if (!signature)
+                        return false; // no signature, no issue
+                    const hashType = signatureHashType(signature);
+                    if (hashType & _8.Transaction.SIGHASH_NONE)
+                        return false; // SIGHASH_NONE doesn't care about outputs
+                    return true; // SIGHASH_* does care
+                });
+            }));
+    }
+    __canModifyOutputs() {
+        const nInputs = this.__TX.ins.length;
+        const nOutputs = this.__TX.outs.length;
+        return this.__INPUTS.every((input) => {
+            if (input.signatures === undefined)
+                return true;
+            return input.signatures.every((signature) => {
+                if (!signature)
+                    return true;
+                const hashType = signatureHashType(signature);
+                const hashTypeMod = hashType & 0x1f;
+                if (hashTypeMod === _8.Transaction.SIGHASH_NONE)
+                    return true;
+                if (hashTypeMod === _8.Transaction.SIGHASH_SINGLE) {
+                    // if SIGHASH_SINGLE is set, and nInputs > nOutputs
+                    // some signatures would be invalidated by the addition
+                    // of more outputs
+                    return nInputs <= nOutputs;
+                }
+                return false;
+            });
+        });
+    }
+    __overMaximumFees(bytes) {
+        // not all inputs will have .value defined
+        const incoming = this.__INPUTS.reduce((a, x) => a + (typeof x.value !== 'undefined' ? BigInt(x.value) : BigInt(0)), BigInt(0));
+        // but all outputs do, and if we have any input value
+        // we can immediately determine if the outputs are too small
+        const outgoing = this.__TX.outs.reduce((a, x) => a + BigInt(x.value), BigInt(0));
+        const fee = incoming - outgoing;
+        const feeRate = Number(fee) / bytes; // assume fee fits within number
+        return feeRate > this.maximumFeeRate;
+    }
+}
+exports.TransactionBuilder = TransactionBuilder;
+function expandInput(scriptSig, witnessStack = [], type, scriptPubKey) {
+    if (scriptSig && scriptSig.length === 0 && witnessStack.length === 0)
+        return {};
+    if (!type) {
+        let ssType = scriptSig ? classify.input(scriptSig, true) : undefined;
+        let wsType = classify.witness(witnessStack, true);
+        if (ssType === SCRIPT_TYPES.NONSTANDARD)
+            ssType = undefined;
+        if (wsType === SCRIPT_TYPES.NONSTANDARD)
+            wsType = undefined;
+        type = ssType || wsType;
+    }
+    switch (type) {
+        case SCRIPT_TYPES.P2WPKH: {
+            const { output, pubkey, signature } = _4.payments.p2wpkh({
+                witness: witnessStack,
+            });
+            return {
+                prevOutScript: output,
+                prevOutType: SCRIPT_TYPES.P2WPKH,
+                pubkeys: [pubkey],
+                signatures: [signature],
+            };
+        }
+        case SCRIPT_TYPES.P2PKH: {
+            const { output, pubkey, signature } = _4.payments.p2pkh({
+                input: scriptSig,
+            });
+            return {
+                prevOutScript: output,
+                prevOutType: SCRIPT_TYPES.P2PKH,
+                pubkeys: [pubkey],
+                signatures: [signature],
+            };
+        }
+        case SCRIPT_TYPES.P2PK: {
+            const { signature } = _4.payments.p2pk({ input: scriptSig });
+            return {
+                prevOutType: SCRIPT_TYPES.P2PK,
+                pubkeys: [undefined],
+                signatures: [signature],
+            };
+        }
+        case SCRIPT_TYPES.P2MS: {
+            const { m, pubkeys, signatures } = _4.payments.p2ms({
+                input: scriptSig,
+                output: scriptPubKey,
+            }, { allowIncomplete: true });
+            return {
+                prevOutType: SCRIPT_TYPES.P2MS,
+                pubkeys,
+                signatures,
+                maxSignatures: m,
+            };
+        }
+        case SCRIPT_TYPES.P2TR_NS: {
+            const { n, pubkeys, signatures } = _1.p2trPayments.p2tr_ns({
+                // Witness signatures are reverse of pubkeys, because it's a stack
+                signatures: witnessStack.length ? witnessStack.reverse() : undefined,
+                output: scriptPubKey,
+            }, { allowIncomplete: true, eccLib: noble_ecc_1.ecc });
+            return {
+                prevOutType: SCRIPT_TYPES.P2TR_NS,
+                pubkeys,
+                signatures,
+                maxSignatures: n,
+            };
+        }
+    }
+    if (type === SCRIPT_TYPES.P2SH) {
+        const { output, redeem } = _4.payments.p2sh({
+            input: scriptSig,
+            witness: witnessStack,
+        });
+        const outputType = classify.output(redeem.output);
+        const expanded = expandInput(redeem.input, redeem.witness, outputType, redeem.output);
+        if (!expanded.prevOutType)
+            return {};
+        return {
+            prevOutScript: output,
+            prevOutType: SCRIPT_TYPES.P2SH,
+            redeemScript: redeem.output,
+            redeemScriptType: expanded.prevOutType,
+            witnessScript: expanded.witnessScript,
+            witnessScriptType: expanded.witnessScriptType,
+            pubkeys: expanded.pubkeys,
+            signatures: expanded.signatures,
+        };
+    }
+    if (type === SCRIPT_TYPES.P2WSH) {
+        const { output, redeem } = _4.payments.p2wsh({
+            input: scriptSig,
+            witness: witnessStack,
+        });
+        const outputType = classify.output(redeem.output);
+        let expanded;
+        if (outputType === SCRIPT_TYPES.P2WPKH) {
+            expanded = expandInput(redeem.input, redeem.witness, outputType);
+        }
+        else {
+            expanded = expandInput(_5.script.compile(redeem.witness), [], outputType, redeem.output);
+        }
+        if (!expanded.prevOutType)
+            return {};
+        return {
+            prevOutScript: output,
+            prevOutType: SCRIPT_TYPES.P2WSH,
+            witnessScript: redeem.output,
+            witnessScriptType: expanded.prevOutType,
+            pubkeys: expanded.pubkeys,
+            signatures: expanded.signatures,
+        };
+    }
+    if (type === SCRIPT_TYPES.P2TR) {
+        const parsedWitness = _7.taproot.parseTaprootWitness(witnessStack);
+        if (parsedWitness.spendType === 'Key') {
+            // key path spend, nothing to expand
+            const { signature, annex } = parsedWitness;
+            return {
+                prevOutType: SCRIPT_TYPES.P2TR,
+                signatures: [signature],
+                annex,
+            };
+        }
+        else {
+            // script path spend
+            const { tapscript, controlBlock, annex } = parsedWitness;
+            const prevOutScript = _1.p2trPayments.p2tr({
+                redeems: [{ output: tapscript }],
+                redeemIndex: 0,
+                controlBlock,
+                annex,
+            }, { eccLib: noble_ecc_1.ecc }).output;
+            const witnessScriptType = classify.output(tapscript);
+            const { pubkeys, signatures } = expandInput(undefined, parsedWitness.scriptSig, witnessScriptType, tapscript);
+            return {
+                prevOutScript,
+                prevOutType: SCRIPT_TYPES.P2TR,
+                witnessScript: tapscript,
+                witnessScriptType,
+                controlBlock,
+                annex,
+                pubkeys,
+                signatures,
+            };
+        }
+    }
+    return {
+        prevOutType: SCRIPT_TYPES.NONSTANDARD,
+        prevOutScript: scriptSig,
+    };
+}
+// could be done in expandInput, but requires the original Transaction for hashForSignature
+function fixMultisigOrder(input, transaction, vin, prevOutputs) {
+    if (input.redeemScriptType !== SCRIPT_TYPES.P2MS || !input.redeemScript)
+        return;
+    if (input.pubkeys.length === input.signatures.length)
+        return;
+    const prevOutput = prevOutputs && prevOutputs[vin];
+    const unmatched = input.signatures.concat();
+    input.signatures = input.pubkeys.map((pubKey) => {
+        const keyPair = noble_ecc_1.ECPair.fromPublicKey(pubKey);
+        let match;
+        // check for a signature
+        unmatched.some((signature, i) => {
+            // skip if undefined || OP_0
+            if (!signature)
+                return false;
+            // TODO: avoid O(n) hashForSignature
+            const parsed = _5.script.signature.decode(signature);
+            const hash = transaction.hashForSignature(vin, input.redeemScript, parsed.hashType, prevOutput === null || prevOutput === void 0 ? void 0 : prevOutput.value);
+            // skip if signature does not match pubKey
+            if (!keyPair.verify(hash, parsed.signature))
+                return false;
+            // remove matched signature from unmatched
+            unmatched[i] = undefined;
+            match = signature;
+            return true;
+        });
+        return match;
+    });
+}
+function expandOutput(script, ourPubKey, controlBlock) {
+    typeforce(types.Buffer, script);
+    const type = classify.output(script);
+    switch (type) {
+        case SCRIPT_TYPES.P2PKH: {
+            if (!ourPubKey)
+                return { type };
+            // does our hash160(pubKey) match the output scripts?
+            const pkh1 = _4.payments.p2pkh({ output: script }).hash;
+            const pkh2 = _2.crypto.hash160(ourPubKey);
+            if (!pkh1.equals(pkh2))
+                return { type };
+            return {
+                type,
+                pubkeys: [ourPubKey],
+                signatures: [undefined],
+            };
+        }
+        case SCRIPT_TYPES.P2WPKH: {
+            if (!ourPubKey)
+                return { type };
+            // does our hash160(pubKey) match the output scripts?
+            const wpkh1 = _4.payments.p2wpkh({ output: script }).hash;
+            const wpkh2 = _2.crypto.hash160(ourPubKey);
+            if (!wpkh1.equals(wpkh2))
+                return { type };
+            return {
+                type,
+                pubkeys: [ourPubKey],
+                signatures: [undefined],
+            };
+        }
+        case SCRIPT_TYPES.P2TR: {
+            if (!ourPubKey)
+                return { type };
+            // HACK ourPubKey to BIP340-style
+            if (ourPubKey.length === 33)
+                ourPubKey = ourPubKey.slice(1);
+            // TODO: support multiple pubkeys
+            const p2tr = _1.p2trPayments.p2tr({ pubkey: ourPubKey, controlBlock }, { eccLib: noble_ecc_1.ecc });
+            // Does tweaked output for a single pubkey match?
+            if (!script.equals(p2tr.output))
+                return { type };
+            // P2TR KeyPath, single key
+            return {
+                type,
+                pubkeys: [ourPubKey],
+                signatures: [undefined],
+            };
+        }
+        case SCRIPT_TYPES.P2TR_NS: {
+            const p2trNs = _1.p2trPayments.p2tr_ns({ output: script }, { eccLib: noble_ecc_1.ecc });
+            // P2TR ScriptPath
+            return {
+                type,
+                pubkeys: p2trNs.pubkeys,
+                signatures: p2trNs.pubkeys.map(() => undefined),
+                maxSignatures: p2trNs.pubkeys.length,
+            };
+        }
+        case SCRIPT_TYPES.P2PK: {
+            const p2pk = _4.payments.p2pk({ output: script });
+            return {
+                type,
+                pubkeys: [p2pk.pubkey],
+                signatures: [undefined],
+            };
+        }
+        case SCRIPT_TYPES.P2MS: {
+            const p2ms = _4.payments.p2ms({ output: script });
+            return {
+                type,
+                pubkeys: p2ms.pubkeys,
+                signatures: p2ms.pubkeys.map(() => undefined),
+                maxSignatures: p2ms.m,
+            };
+        }
+    }
+    return { type };
+}
+function prepareInput(input, ourPubKey, redeemScript, witnessScript, controlBlock, annex) {
+    if (redeemScript && witnessScript) {
+        const p2wsh = _4.payments.p2wsh({
+            redeem: { output: witnessScript },
+        });
+        const p2wshAlt = _4.payments.p2wsh({ output: redeemScript });
+        const p2sh = _4.payments.p2sh({ redeem: { output: redeemScript } });
+        const p2shAlt = _4.payments.p2sh({ redeem: p2wsh });
+        // enforces P2SH(P2WSH(...))
+        if (!p2wsh.hash.equals(p2wshAlt.hash))
+            throw new Error('Witness script inconsistent with prevOutScript');
+        if (!p2sh.hash.equals(p2shAlt.hash))
+            throw new Error('Redeem script inconsistent with prevOutScript');
+        const expanded = expandOutput(p2wsh.redeem.output, ourPubKey);
+        if (!expanded.pubkeys) {
+            throw new Error(expanded.type + ' not supported as witnessScript (' + _5.script.toASM(witnessScript) + ')');
+        }
+        if (input.signatures && input.signatures.some((x) => x !== undefined)) {
+            expanded.signatures = input.signatures;
+        }
+        const signScript = witnessScript;
+        if (expanded.type === SCRIPT_TYPES.P2WPKH)
+            throw new Error('P2SH(P2WSH(P2WPKH)) is a consensus failure');
+        return {
+            redeemScript,
+            redeemScriptType: SCRIPT_TYPES.P2WSH,
+            witnessScript,
+            witnessScriptType: expanded.type,
+            prevOutType: SCRIPT_TYPES.P2SH,
+            prevOutScript: p2sh.output,
+            witnessVersion: 0,
+            signScript,
+            signType: expanded.type,
+            pubkeys: expanded.pubkeys,
+            signatures: expanded.signatures,
+            maxSignatures: expanded.maxSignatures,
+        };
+    }
+    if (redeemScript) {
+        const p2sh = _4.payments.p2sh({ redeem: { output: redeemScript } });
+        if (input.prevOutScript) {
+            let p2shAlt;
+            try {
+                p2shAlt = _4.payments.p2sh({ output: input.prevOutScript });
+            }
+            catch (e) {
+                throw new Error('PrevOutScript must be P2SH');
+            }
+            if (!p2sh.hash.equals(p2shAlt.hash))
+                throw new Error('Redeem script inconsistent with prevOutScript');
+        }
+        const expanded = expandOutput(p2sh.redeem.output, ourPubKey);
+        if (!expanded.pubkeys) {
+            throw new Error(expanded.type + ' not supported as redeemScript (' + _5.script.toASM(redeemScript) + ')');
+        }
+        if (input.signatures && input.signatures.some((x) => x !== undefined)) {
+            expanded.signatures = input.signatures;
+        }
+        let signScript = redeemScript;
+        if (expanded.type === SCRIPT_TYPES.P2WPKH) {
+            signScript = _4.payments.p2pkh({ pubkey: expanded.pubkeys[0] }).output;
+        }
+        return {
+            redeemScript,
+            redeemScriptType: expanded.type,
+            prevOutType: SCRIPT_TYPES.P2SH,
+            prevOutScript: p2sh.output,
+            witnessVersion: expanded.type === SCRIPT_TYPES.P2WPKH ? 0 : undefined,
+            signScript,
+            signType: expanded.type,
+            pubkeys: expanded.pubkeys,
+            signatures: expanded.signatures,
+            maxSignatures: expanded.maxSignatures,
+        };
+    }
+    if (witnessScript && controlBlock) {
+        // P2TR ScriptPath
+        /* tslint:disable-next-line:no-shadowed-variable */
+        let prevOutScript = input.prevOutScript;
+        if (!prevOutScript) {
+            prevOutScript = _1.p2trPayments.p2tr({
+                redeems: [{ output: witnessScript }],
+                redeemIndex: 0,
+                controlBlock,
+                annex,
+            }, { eccLib: noble_ecc_1.ecc }).output;
+        }
+        const expanded = expandOutput(witnessScript, ourPubKey);
+        if (!expanded.pubkeys) {
+            throw new Error(expanded.type + ' not supported as witnessScript (' + _5.script.toASM(witnessScript) + ')');
+        }
+        if (input.signatures && input.signatures.some((x) => x !== undefined)) {
+            expanded.signatures = input.signatures;
+        }
+        return {
+            witnessScript,
+            witnessScriptType: expanded.type,
+            prevOutType: SCRIPT_TYPES.P2TR,
+            prevOutScript,
+            witnessVersion: 1,
+            signScript: witnessScript,
+            signType: expanded.type,
+            pubkeys: expanded.pubkeys,
+            signatures: expanded.signatures,
+            maxSignatures: expanded.maxSignatures,
+            controlBlock,
+            annex,
+        };
+    }
+    if (witnessScript) {
+        const p2wsh = _4.payments.p2wsh({ redeem: { output: witnessScript } });
+        if (input.prevOutScript) {
+            const p2wshAlt = _4.payments.p2wsh({ output: input.prevOutScript });
+            if (!p2wsh.hash.equals(p2wshAlt.hash))
+                throw new Error('Witness script inconsistent with prevOutScript');
+        }
+        const expanded = expandOutput(p2wsh.redeem.output, ourPubKey);
+        if (!expanded.pubkeys) {
+            throw new Error(expanded.type + ' not supported as witnessScript (' + _5.script.toASM(witnessScript) + ')');
+        }
+        if (input.signatures && input.signatures.some((x) => x !== undefined)) {
+            expanded.signatures = input.signatures;
+        }
+        const signScript = witnessScript;
+        if (expanded.type === SCRIPT_TYPES.P2WPKH)
+            throw new Error('P2WSH(P2WPKH) is a consensus failure');
+        return {
+            witnessScript,
+            witnessScriptType: expanded.type,
+            prevOutType: SCRIPT_TYPES.P2WSH,
+            prevOutScript: p2wsh.output,
+            witnessVersion: 0,
+            signScript,
+            signType: expanded.type,
+            pubkeys: expanded.pubkeys,
+            signatures: expanded.signatures,
+            maxSignatures: expanded.maxSignatures,
+        };
+    }
+    if (input.prevOutType && input.prevOutScript) {
+        // embedded scripts are not possible without extra information
+        if (input.prevOutType === SCRIPT_TYPES.P2SH) {
+            throw new Error('PrevOutScript is ' + input.prevOutType + ', requires redeemScript');
+        }
+        if (input.prevOutType === SCRIPT_TYPES.P2WSH) {
+            throw new Error('PrevOutScript is ' + input.prevOutType + ', requires witnessScript');
+        }
+        const expanded = expandOutput(input.prevOutScript, ourPubKey);
+        if (!expanded.pubkeys) {
+            throw new Error(expanded.type + ' not supported (' + _5.script.toASM(input.prevOutScript) + ')');
+        }
+        if (input.signatures && input.signatures.some((x) => x !== undefined)) {
+            expanded.signatures = input.signatures;
+        }
+        let signScript = input.prevOutScript;
+        if (expanded.type === SCRIPT_TYPES.P2WPKH) {
+            signScript = _4.payments.p2pkh({ pubkey: expanded.pubkeys[0] }).output;
+        }
+        let witnessVersion;
+        if (expanded.type === SCRIPT_TYPES.P2WPKH) {
+            witnessVersion = 0;
+        }
+        else if (expanded.type === SCRIPT_TYPES.P2TR) {
+            witnessVersion = 1;
+        }
+        return {
+            prevOutType: expanded.type,
+            prevOutScript: input.prevOutScript,
+            witnessVersion,
+            signScript,
+            signType: expanded.type,
+            pubkeys: expanded.pubkeys,
+            signatures: expanded.signatures,
+            maxSignatures: expanded.maxSignatures,
+        };
+    }
+    const prevOutScript = _4.payments.p2pkh({ pubkey: ourPubKey }).output;
+    return {
+        prevOutType: SCRIPT_TYPES.P2PKH,
+        prevOutScript,
+        signScript: prevOutScript,
+        signType: SCRIPT_TYPES.P2PKH,
+        pubkeys: [ourPubKey],
+        signatures: [undefined],
+    };
+}
+function build(type, input, allowIncomplete) {
+    const pubkeys = (input.pubkeys || []);
+    let signatures = (input.signatures || []);
+    switch (type) {
+        case SCRIPT_TYPES.P2PKH: {
+            if (pubkeys.length === 0)
+                break;
+            if (signatures.length === 0)
+                break;
+            return _4.payments.p2pkh({ pubkey: pubkeys[0], signature: signatures[0] });
+        }
+        case SCRIPT_TYPES.P2WPKH: {
+            if (pubkeys.length === 0)
+                break;
+            if (signatures.length === 0)
+                break;
+            return _4.payments.p2wpkh({ pubkey: pubkeys[0], signature: signatures[0] });
+        }
+        case SCRIPT_TYPES.P2PK: {
+            if (pubkeys.length === 0)
+                break;
+            if (signatures.length === 0)
+                break;
+            return _4.payments.p2pk({ signature: signatures[0] });
+        }
+        case SCRIPT_TYPES.P2MS: {
+            const m = input.maxSignatures;
+            if (allowIncomplete) {
+                signatures = signatures.map((x) => x || _6.opcodes.OP_0);
+            }
+            else {
+                signatures = signatures.filter((x) => x);
+            }
+            // if the transaction is not not complete (complete), or if signatures.length === m, validate
+            // otherwise, the number of OP_0's may be >= m, so don't validate (boo)
+            const validate = !allowIncomplete || m === signatures.length;
+            return _4.payments.p2ms({ m, pubkeys, signatures }, { allowIncomplete, validate });
+        }
+        case SCRIPT_TYPES.P2SH: {
+            const redeem = build(input.redeemScriptType, input, allowIncomplete);
+            if (!redeem)
+                return;
+            return _4.payments.p2sh({
+                redeem: {
+                    output: redeem.output || input.redeemScript,
+                    input: redeem.input,
+                    witness: redeem.witness,
+                },
+            });
+        }
+        case SCRIPT_TYPES.P2WSH: {
+            const redeem = build(input.witnessScriptType, input, allowIncomplete);
+            if (!redeem)
+                return;
+            return _4.payments.p2wsh({
+                redeem: {
+                    output: input.witnessScript,
+                    input: redeem.input,
+                    witness: redeem.witness,
+                },
+            });
+        }
+        case SCRIPT_TYPES.P2TR: {
+            if (input.witnessScriptType === SCRIPT_TYPES.P2TR_NS) {
+                // ScriptPath
+                const redeem = build(input.witnessScriptType, input, allowIncomplete);
+                return _1.p2trPayments.p2tr({
+                    output: input.prevOutScript,
+                    controlBlock: input.controlBlock,
+                    annex: input.annex,
+                    redeems: [redeem],
+                    redeemIndex: 0,
+                }, { eccLib: noble_ecc_1.ecc });
+            }
+            // KeyPath
+            if (signatures.length === 0)
+                break;
+            return _1.p2trPayments.p2tr({ pubkeys, signature: signatures[0] }, { eccLib: noble_ecc_1.ecc });
+        }
+        case SCRIPT_TYPES.P2TR_NS: {
+            const m = input.maxSignatures;
+            if (allowIncomplete) {
+                signatures = signatures.map((x) => x || _6.opcodes.OP_0);
+            }
+            else {
+                signatures = signatures.filter((x) => x);
+            }
+            // if the transaction is not not complete (complete), or if signatures.length === m, validate
+            // otherwise, the number of OP_0's may be >= m, so don't validate (boo)
+            const validate = !allowIncomplete || m === signatures.length;
+            return _1.p2trPayments.p2tr_ns({ pubkeys, signatures }, { allowIncomplete, validate, eccLib: noble_ecc_1.ecc });
+        }
+    }
+}
+function canSign(input) {
+    return (input.signScript !== undefined &&
+        input.signType !== undefined &&
+        input.pubkeys !== undefined &&
+        input.signatures !== undefined &&
+        input.signatures.length === input.pubkeys.length &&
+        input.pubkeys.length > 0 &&
+        (input.witnessVersion === undefined || input.value !== undefined));
+}
+function signatureHashType(buffer) {
+    if (_5.script.isCanonicalSchnorrSignature(buffer) && buffer.length === 64) {
+        return _8.Transaction.SIGHASH_DEFAULT;
+    }
+    return buffer.readUInt8(buffer.length - 1);
+}
+function checkSignArgs(inputs, signParams) {
+    if (!PREVOUT_TYPES.has(signParams.prevOutScriptType)) {
+        throw new TypeError(`Unknown prevOutScriptType "${signParams.prevOutScriptType}"`);
+    }
+    tfMessage(typeforce.Number, signParams.vin, `sign must include vin parameter as Number (input index)`);
+    tfMessage(tfFullSigner, signParams.keyPair, `sign must include keyPair parameter as Signer interface`);
+    tfMessage(typeforce.maybe(typeforce.Number), signParams.hashType, `sign hashType parameter must be a number`);
+    const prevOutType = (inputs[signParams.vin] || []).prevOutType;
+    const posType = signParams.prevOutScriptType;
+    switch (posType) {
+        case 'p2pkh':
+            if (prevOutType && prevOutType !== 'pubkeyhash') {
+                throw new TypeError(`input #${signParams.vin} is not of type p2pkh: ${prevOutType}`);
+            }
+            tfMessage(typeforce.value(undefined), signParams.witnessScript, `${posType} requires NO witnessScript`);
+            tfMessage(typeforce.value(undefined), signParams.redeemScript, `${posType} requires NO redeemScript`);
+            tfMessage(typeforce.value(undefined), signParams.witnessValue, `${posType} requires NO witnessValue`);
+            break;
+        case 'p2pk':
+            if (prevOutType && prevOutType !== 'pubkey') {
+                throw new TypeError(`input #${signParams.vin} is not of type p2pk: ${prevOutType}`);
+            }
+            tfMessage(typeforce.value(undefined), signParams.witnessScript, `${posType} requires NO witnessScript`);
+            tfMessage(typeforce.value(undefined), signParams.redeemScript, `${posType} requires NO redeemScript`);
+            tfMessage(typeforce.value(undefined), signParams.witnessValue, `${posType} requires NO witnessValue`);
+            break;
+        case 'p2wpkh':
+            if (prevOutType && prevOutType !== 'witnesspubkeyhash') {
+                throw new TypeError(`input #${signParams.vin} is not of type p2wpkh: ${prevOutType}`);
+            }
+            tfMessage(typeforce.value(undefined), signParams.witnessScript, `${posType} requires NO witnessScript`);
+            tfMessage(typeforce.value(undefined), signParams.redeemScript, `${posType} requires NO redeemScript`);
+            tfMessage(types.Satoshi, signParams.witnessValue, `${posType} requires witnessValue`);
+            break;
+        case 'p2ms':
+            if (prevOutType && prevOutType !== 'multisig') {
+                throw new TypeError(`input #${signParams.vin} is not of type p2ms: ${prevOutType}`);
+            }
+            tfMessage(typeforce.value(undefined), signParams.witnessScript, `${posType} requires NO witnessScript`);
+            tfMessage(typeforce.value(undefined), signParams.redeemScript, `${posType} requires NO redeemScript`);
+            tfMessage(typeforce.value(undefined), signParams.witnessValue, `${posType} requires NO witnessValue`);
+            break;
+        case 'p2sh-p2wpkh':
+            if (prevOutType && prevOutType !== 'scripthash') {
+                throw new TypeError(`input #${signParams.vin} is not of type p2sh-p2wpkh: ${prevOutType}`);
+            }
+            tfMessage(typeforce.value(undefined), signParams.witnessScript, `${posType} requires NO witnessScript`);
+            tfMessage(typeforce.Buffer, signParams.redeemScript, `${posType} requires redeemScript`);
+            tfMessage(types.Satoshi, signParams.witnessValue, `${posType} requires witnessValue`);
+            break;
+        case 'p2sh-p2ms':
+        case 'p2sh-p2pk':
+        case 'p2sh-p2pkh':
+            if (prevOutType && prevOutType !== 'scripthash') {
+                throw new TypeError(`input #${signParams.vin} is not of type ${posType}: ${prevOutType}`);
+            }
+            tfMessage(typeforce.value(undefined), signParams.witnessScript, `${posType} requires NO witnessScript`);
+            tfMessage(typeforce.Buffer, signParams.redeemScript, `${posType} requires redeemScript`);
+            tfMessage(typeforce.value(undefined), signParams.witnessValue, `${posType} requires NO witnessValue`);
+            break;
+        case 'p2wsh-p2ms':
+        case 'p2wsh-p2pk':
+        case 'p2wsh-p2pkh':
+            if (prevOutType && prevOutType !== 'witnessscripthash') {
+                throw new TypeError(`input #${signParams.vin} is not of type ${posType}: ${prevOutType}`);
+            }
+            tfMessage(typeforce.Buffer, signParams.witnessScript, `${posType} requires witnessScript`);
+            tfMessage(typeforce.value(undefined), signParams.redeemScript, `${posType} requires NO redeemScript`);
+            tfMessage(types.Satoshi, signParams.witnessValue, `${posType} requires witnessValue`);
+            break;
+        case 'p2sh-p2wsh-p2ms':
+        case 'p2sh-p2wsh-p2pk':
+        case 'p2sh-p2wsh-p2pkh':
+            if (prevOutType && prevOutType !== 'scripthash') {
+                throw new TypeError(`input #${signParams.vin} is not of type ${posType}: ${prevOutType}`);
+            }
+            tfMessage(typeforce.Buffer, signParams.witnessScript, `${posType} requires witnessScript`);
+            tfMessage(typeforce.Buffer, signParams.redeemScript, `${posType} requires witnessScript`);
+            tfMessage(types.Satoshi, signParams.witnessValue, `${posType} requires witnessScript`);
+            break;
+        case 'p2tr':
+            if (prevOutType && prevOutType !== 'taproot') {
+                throw new TypeError(`input #${signParams.vin} is not of type ${posType}: ${prevOutType}`);
+            }
+            tfMessage(typeforce.value(undefined), signParams.witnessScript, `${posType} requires NO witnessScript`);
+            tfMessage(typeforce.value(undefined), signParams.redeemScript, `${posType} requires NO redeemScript`);
+            tfMessage(typeforce.value(undefined), signParams.witnessValue, `${posType} requires NO witnessValue`);
+            break;
+        case 'p2tr-p2ns':
+            if (prevOutType && prevOutType !== 'taproot') {
+                throw new TypeError(`input #${signParams.vin} is not of type ${posType}: ${prevOutType}`);
+            }
+            inputs[signParams.vin].prevOutType = inputs[signParams.vin].prevOutType || 'taproot';
+            tfMessage(typeforce.Buffer, signParams.witnessScript, `${posType} requires witnessScript`);
+            tfMessage(typeforce.Buffer, signParams.controlBlock, `${posType} requires controlBlock`);
+            tfMessage(typeforce.value(undefined), signParams.redeemScript, `${posType} requires NO redeemScript`);
+            break;
+    }
+}
+function trySign({ input, ourPubKey, keyPair, signatureHash, hashType, useLowR, taptreeRoot, }) {
+    if (input.witnessVersion === 1 && ourPubKey.length === 33)
+        ourPubKey = ourPubKey.slice(1);
+    // enforce in order signing of public keys
+    let signed = false;
+    for (const [i, pubKey] of input.pubkeys.entries()) {
+        if (!ourPubKey.equals(pubKey))
+            continue;
+        if (input.signatures[i] && input.signatures[i].length > 0)
+            throw new Error('Signature already exists');
+        // TODO: add tests
+        if (ourPubKey.length !== 33 && input.witnessVersion === 0) {
+            throw new Error('BIP143 (Witness v0) inputs require compressed pubkeys');
+        }
+        else if (ourPubKey.length !== 32 && input.witnessVersion === 1) {
+            throw new Error('BIP341 (Witness v1) inputs require x-only pubkeys');
+        }
+        if (input.witnessVersion === 1) {
+            if (!input.witnessScript) {
+                // FIXME: Workaround for not having proper tweaking support for key path
+                if (!keyPair.privateKey) {
+                    throw new Error(`unexpected keypair`);
+                }
+                const privateKey = _7.taproot.tapTweakPrivkey(noble_ecc_1.ecc, ourPubKey, keyPair.privateKey, taptreeRoot);
+                keyPair = noble_ecc_1.ECPair.fromPrivateKey(Buffer.from(privateKey));
+            }
+            // https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki#common-signature-message
+            const signature = keyPair.signSchnorr(signatureHash);
+            // SIGHASH_DEFAULT is omitted from the signature
+            if (hashType === _8.Transaction.SIGHASH_DEFAULT) {
+                input.signatures[i] = Buffer.from(signature);
+            }
+            else {
+                input.signatures[i] = Buffer.concat([signature, Buffer.of(hashType)]);
+            }
+        }
+        else {
+            const signature = keyPair.sign(signatureHash, useLowR);
+            input.signatures[i] = _5.script.signature.encode(signature, hashType);
+        }
+        signed = true;
+    }
+    if (!signed)
+        throw new Error('Key pair cannot sign for this input');
+}
+function getSigningData(network, inputs, needsOutputs, tx, signParams, keyPair, redeemScript, hashType, witnessValue, witnessScript, controlBlock, annex, useLowR) {
+    let vin;
+    if (typeof signParams === 'number') {
+        console.warn('DEPRECATED: TransactionBuilder sign method arguments ' + 'will change in v6, please use the TxbSignArg interface');
+        vin = signParams;
+    }
+    else if (typeof signParams === 'object') {
+        checkSignArgs(inputs, signParams);
+        ({ vin, keyPair, redeemScript, hashType, witnessValue, witnessScript, controlBlock, annex } = signParams);
+    }
+    else {
+        throw new TypeError('TransactionBuilder sign first arg must be TxbSignArg or number');
+    }
+    if (keyPair === undefined) {
+        throw new Error('sign requires keypair');
+    }
+    if (!inputs[vin])
+        throw new Error('No input at index: ' + vin);
+    const input = inputs[vin];
+    // if redeemScript was previously provided, enforce consistency
+    if (input.redeemScript !== undefined && redeemScript && !input.redeemScript.equals(redeemScript)) {
+        throw new Error('Inconsistent redeemScript');
+    }
+    const ourPubKey = keyPair.publicKey || (keyPair.getPublicKey && keyPair.getPublicKey());
+    if (!canSign(input)) {
+        if (witnessValue !== undefined) {
+            if (input.value !== undefined && input.value !== witnessValue) {
+                throw new Error('Input did not match witnessValue');
+            }
+            typeforce(types.Satoshi, witnessValue);
+            input.value = witnessValue;
+        }
+        if (!canSign(input)) {
+            const prepared = prepareInput(input, ourPubKey, redeemScript, witnessScript, controlBlock, annex);
+            // updates inline
+            Object.assign(input, prepared);
+        }
+        if (!canSign(input))
+            throw Error(input.prevOutType + ' not supported');
+    }
+    // hashType can be 0 in Taproot, so can't use hashType || SIGHASH_ALL
+    if (input.witnessVersion === 1) {
+        hashType = hashType === undefined ? _8.Transaction.SIGHASH_DEFAULT : hashType;
+    }
+    else {
+        hashType = hashType || _8.Transaction.SIGHASH_ALL;
+    }
+    if (needsOutputs(hashType))
+        throw new Error('Transaction needs outputs');
+    // TODO: This is not the best place to do this, but might stick with it until PSBT
+    let leafHash;
+    let taptreeRoot;
+    if (controlBlock && witnessScript) {
+        leafHash = _7.taproot.getTapleafHash(noble_ecc_1.ecc, controlBlock, witnessScript);
+        taptreeRoot = _7.taproot.getTaptreeRoot(noble_ecc_1.ecc, controlBlock, witnessScript, leafHash);
+    }
+    // ready to sign
+    let signatureHash;
+    switch (input.witnessVersion) {
+        case undefined:
+            signatureHash = tx.hashForSignature(vin, input.signScript, hashType, input.value);
+            break;
+        case 0:
+            signatureHash = tx.hashForWitnessV0(vin, input.signScript, input.value, hashType);
+            break;
+        case 1:
+            signatureHash = tx.hashForWitnessV1(vin, inputs.map(({ prevOutScript }) => prevOutScript), inputs.map(({ value }) => value), hashType, leafHash);
+            break;
+        default:
+            throw new TypeError('Unsupported witness version');
+    }
+    return {
+        input,
+        ourPubKey,
+        keyPair,
+        signatureHash,
+        hashType,
+        useLowR: !!useLowR,
+        taptreeRoot,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction_builder.js","sourceRoot":"","sources":["../../src/transaction_builder.ts"],"names":[],"mappings":"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","sourcesContent":["import * as types from 'bitcoinjs-lib/src/types';\nimport { address as baddress, p2trPayments } from './';\nimport * as bufferutils from 'bitcoinjs-lib/src/bufferutils';\nimport * as classify from './classify';\nimport { crypto as bcrypto } from './';\nimport { networks } from './';\nimport { Network } from './';\nimport { payments } from './';\nimport { Payment } from './';\nimport { script as bscript } from './';\nimport { opcodes as ops } from './';\nimport { taproot } from './';\nimport { TxOutput, Transaction } from './';\nimport { ECPair, ecc as eccLib } from './noble_ecc';\n\nexport interface Signer {\n  privateKey?: Buffer;\n  publicKey: Buffer;\n  getPublicKey?(): Buffer;\n  sign(hash: Buffer, lowR?: boolean): Buffer;\n  signSchnorr(hash: Buffer): Buffer;\n}\n\nconst typeforce = require('typeforce');\n\nconst tfFullSigner = (obj: any): boolean => {\n  return typeforce.Buffer(obj.publicKey) && typeof obj.sign === 'function' && typeof obj.signSchnorr === 'function';\n};\n\nconst SCRIPT_TYPES = classify.types;\n\nconst PREVOUT_TYPES: Set<string> = new Set([\n  // Raw\n  'p2pkh',\n  'p2pk',\n  'p2wpkh',\n  'p2ms',\n  // P2SH wrapped\n  'p2sh-p2pkh',\n  'p2sh-p2pk',\n  'p2sh-p2wpkh',\n  'p2sh-p2ms',\n  // P2WSH wrapped\n  'p2wsh-p2pkh',\n  'p2wsh-p2pk',\n  'p2wsh-p2ms',\n  // P2SH-P2WSH wrapper\n  'p2sh-p2wsh-p2pkh',\n  'p2sh-p2wsh-p2pk',\n  'p2sh-p2wsh-p2ms',\n  // P2TR KeyPath\n  'p2tr',\n  // P2TR ScriptPath\n  'p2tr-p2ns',\n]);\n\ntype MaybeBuffer = Buffer | undefined;\ntype TxbSignatures = Buffer[] | MaybeBuffer[];\ntype TxbPubkeys = MaybeBuffer[];\ntype TxbWitness = Buffer[];\ntype TxbScriptType = string;\ntype TxbScript = Buffer;\n\ninterface TxbInput<TNumber extends number | bigint = number> {\n  value?: TNumber;\n  witnessVersion?: number;\n  signScript?: TxbScript;\n  signType?: TxbScriptType;\n  prevOutScript?: TxbScript;\n  redeemScript?: TxbScript;\n  redeemScriptType?: TxbScriptType;\n  prevOutType?: TxbScriptType;\n  pubkeys?: TxbPubkeys;\n  signatures?: TxbSignatures;\n  witness?: TxbWitness;\n  witnessScript?: TxbScript;\n  witnessScriptType?: TxbScriptType;\n  controlBlock?: Buffer;\n  annex?: Buffer;\n  script?: TxbScript;\n  sequence?: number;\n  scriptSig?: TxbScript;\n  maxSignatures?: number;\n}\n\ninterface TxbOutput {\n  type: string;\n  pubkeys?: TxbPubkeys;\n  signatures?: TxbSignatures;\n  maxSignatures?: number;\n}\n\ninterface TxbSignArg<TNumber extends number | bigint = number> {\n  prevOutScriptType: string;\n  vin: number;\n  keyPair: Signer;\n  redeemScript?: Buffer;\n  hashType?: number;\n  witnessValue?: TNumber;\n  witnessScript?: Buffer;\n  controlBlock?: Buffer;\n  annex?: Buffer;\n}\n\nfunction tfMessage(type: any, value: any, message: string): void {\n  try {\n    typeforce(type, value);\n  } catch (err) {\n    throw new Error(message);\n  }\n}\n\nfunction txIsString<TNumber extends number | bigint = number>(\n  tx: Buffer | string | Transaction<TNumber>\n): tx is string {\n  return typeof tx === 'string' || tx instanceof String;\n}\n\nfunction txIsTransaction<TNumber extends number | bigint = number>(\n  tx: Buffer | string | Transaction<TNumber>\n): tx is Transaction<TNumber> {\n  return tx instanceof Transaction;\n}\n\nexport class TransactionBuilder<TNumber extends number | bigint = number> {\n  static fromTransaction<TNumber extends number | bigint = number>(\n    transaction: Transaction<TNumber>,\n    network?: Network,\n    prevOutputs?: TxOutput<TNumber>[]\n  ): TransactionBuilder<TNumber> {\n    const txb = new TransactionBuilder<TNumber>(network);\n\n    // Copy transaction fields\n    txb.setVersion(transaction.version);\n    txb.setLockTime(transaction.locktime);\n\n    // Copy outputs (done first to avoid signature invalidation)\n    transaction.outs.forEach((txOut) => {\n      txb.addOutput(txOut.script, (txOut as TxOutput<TNumber>).value);\n    });\n\n    // Copy inputs\n    transaction.ins.forEach((txIn) => {\n      txb.__addInputUnsafe(txIn.hash, txIn.index, {\n        sequence: txIn.sequence,\n        script: txIn.script,\n        witness: txIn.witness,\n      });\n    });\n\n    // fix some things not possible through the public API\n    txb.__INPUTS.forEach((input, i) => {\n      fixMultisigOrder<TNumber>(input, transaction, i, prevOutputs);\n    });\n\n    return txb;\n  }\n\n  private __PREV_TX_SET: { [index: string]: boolean };\n  private __INPUTS: Array<TxbInput<TNumber>>;\n  private __TX: Transaction<TNumber>;\n  private __USE_LOW_R: boolean;\n\n  // WARNING: maximumFeeRate is __NOT__ to be relied on,\n  //          it's just another potential safety mechanism (safety in-depth)\n  constructor(public network: Network = networks.bitcoin, public maximumFeeRate: number = 2500) {\n    this.__PREV_TX_SET = {};\n    this.__INPUTS = [];\n    this.__TX = new Transaction<TNumber>();\n    this.__TX.version = 2;\n    this.__USE_LOW_R = false;\n    console.warn(\n      'Deprecation Warning: TransactionBuilder will be removed in the future. ' +\n        '(v6.x.x or later) Please use the Psbt class instead. Examples of usage ' +\n        'are available in the transactions-psbt.js integration test file on our ' +\n        'Github. A high level explanation is available in the psbt.ts and psbt.js ' +\n        'files as well.'\n    );\n  }\n\n  setLowR(setting?: boolean): boolean {\n    typeforce(typeforce.maybe(typeforce.Boolean), setting);\n    if (setting === undefined) {\n      setting = true;\n    }\n    this.__USE_LOW_R = setting;\n    return setting;\n  }\n\n  setLockTime(locktime: number): void {\n    typeforce(types.UInt32, locktime);\n\n    // if any signatures exist, throw\n    if (\n      this.__INPUTS.some((input) => {\n        if (!input.signatures) return false;\n\n        return input.signatures.some((s) => s !== undefined);\n      })\n    ) {\n      throw new Error('No, this would invalidate signatures');\n    }\n\n    this.__TX.locktime = locktime;\n  }\n\n  setVersion(version: number): void {\n    typeforce(types.UInt32, version);\n\n    // XXX: this might eventually become more complex depending on what the versions represent\n    this.__TX.version = version;\n  }\n\n  addInput(\n    txHash: Buffer | string | Transaction<TNumber>,\n    vout: number,\n    sequence?: number,\n    prevOutScript?: Buffer,\n    value?: TNumber\n  ): number {\n    if (!this.__canModifyInputs()) {\n      throw new Error('No, this would invalidate signatures');\n    }\n\n    // is it a hex string?\n    if (txIsString(txHash)) {\n      // transaction hashs's are displayed in reverse order, un-reverse it\n      txHash = bufferutils.reverseBuffer(Buffer.from(txHash, 'hex'));\n\n      // is it a Transaction object?\n    } else if (txIsTransaction(txHash)) {\n      const txOut = txHash.outs[vout];\n      prevOutScript = txOut.script;\n      value = (txOut as TxOutput<TNumber>).value;\n\n      txHash = txHash.getHash(false) as Buffer;\n    }\n\n    return this.__addInputUnsafe(txHash, vout, {\n      sequence,\n      prevOutScript,\n      value,\n    });\n  }\n\n  addOutput(scriptPubKey: string | Buffer, value: TNumber): number {\n    if (!this.__canModifyOutputs()) {\n      throw new Error('No, this would invalidate signatures');\n    }\n\n    // Attempt to get a script if it's a base58 or bech32 address string\n    if (typeof scriptPubKey === 'string') {\n      scriptPubKey = baddress.toOutputScript(scriptPubKey, this.network);\n    }\n\n    return this.__TX.addOutput(scriptPubKey, value);\n  }\n\n  build(): Transaction<TNumber> {\n    return this.__build(false);\n  }\n\n  buildIncomplete(): Transaction<TNumber> {\n    return this.__build(true);\n  }\n\n  sign(\n    signParams: number | TxbSignArg<TNumber>,\n    keyPair?: Signer,\n    redeemScript?: Buffer,\n    hashType?: number,\n    witnessValue?: TNumber,\n    witnessScript?: Buffer,\n    controlBlock?: Buffer,\n    annex?: Buffer\n  ): void {\n    trySign<TNumber>(\n      getSigningData<TNumber>(\n        this.network,\n        this.__INPUTS,\n        this.__needsOutputs.bind(this),\n        this.__TX,\n        signParams,\n        keyPair,\n        redeemScript,\n        hashType,\n        witnessValue,\n        witnessScript,\n        controlBlock,\n        annex,\n        this.__USE_LOW_R\n      )\n    );\n  }\n\n  private __addInputUnsafe(txHash: Buffer, vout: number, options: TxbInput<TNumber>): number {\n    if (Transaction.isCoinbaseHash(txHash)) {\n      throw new Error('coinbase inputs not supported');\n    }\n\n    const prevTxOut = txHash.toString('hex') + ':' + vout;\n    if (this.__PREV_TX_SET[prevTxOut] !== undefined) throw new Error('Duplicate TxOut: ' + prevTxOut);\n\n    let input: TxbInput<TNumber> = {};\n\n    // derive what we can from the scriptSig\n    if (options.script !== undefined || options.witness !== undefined) {\n      input = expandInput<TNumber>(options.script, options.witness);\n    }\n\n    // if an input value was given, retain it\n    if (options.value !== undefined) {\n      input.value = options.value;\n    }\n\n    // derive what we can from the previous transactions output script\n    if (!input.prevOutScript && options.prevOutScript) {\n      let prevOutType;\n\n      if (!input.pubkeys && !input.signatures) {\n        const expanded = expandOutput(options.prevOutScript);\n        if (expanded.pubkeys) {\n          input.pubkeys = expanded.pubkeys;\n          input.signatures = expanded.signatures;\n        }\n\n        prevOutType = expanded.type;\n      }\n\n      input.prevOutScript = options.prevOutScript;\n      input.prevOutType = prevOutType || classify.output(options.prevOutScript);\n    }\n\n    const vin = this.__TX.addInput(txHash, vout, options.sequence, options.scriptSig);\n    this.__INPUTS[vin] = input;\n    this.__PREV_TX_SET[prevTxOut] = true;\n    return vin;\n  }\n\n  private __build(allowIncomplete?: boolean): Transaction<TNumber> {\n    if (!allowIncomplete) {\n      if (!this.__TX.ins.length) throw new Error('Transaction has no inputs');\n      if (!this.__TX.outs.length) throw new Error('Transaction has no outputs');\n    }\n\n    const tx = this.__TX.clone();\n\n    // create script signatures from inputs\n    this.__INPUTS.forEach((input, i) => {\n      if (!input.prevOutType && !allowIncomplete) throw new Error('Transaction is not complete');\n\n      const result = build<TNumber>(input.prevOutType!, input, allowIncomplete);\n      if (!result) {\n        if (!allowIncomplete && input.prevOutType === SCRIPT_TYPES.NONSTANDARD) throw new Error('Unknown input type');\n        if (!allowIncomplete) throw new Error('Not enough information');\n        return;\n      }\n\n      if (result.input) {\n        tx.setInputScript(i, result.input);\n      }\n      tx.setWitness(i, result.witness!);\n    });\n\n    if (!allowIncomplete) {\n      // do not rely on this, its merely a last resort\n      if (this.__overMaximumFees(tx.virtualSize())) {\n        throw new Error('Transaction has absurd fees');\n      }\n    }\n\n    return tx;\n  }\n\n  private __canModifyInputs(): boolean {\n    return this.__INPUTS.every((input) => {\n      if (!input.signatures) return true;\n\n      return input.signatures.every((signature) => {\n        if (!signature) return true;\n        const hashType = signatureHashType(signature);\n\n        // if SIGHASH_ANYONECANPAY is set, signatures would not\n        // be invalidated by more inputs\n        return (hashType & Transaction.SIGHASH_ANYONECANPAY) !== 0;\n      });\n    });\n  }\n\n  private __needsOutputs(signingHashType: number): boolean {\n    if (signingHashType === Transaction.SIGHASH_ALL || signingHashType === Transaction.SIGHASH_DEFAULT) {\n      return this.__TX.outs.length === 0;\n    }\n\n    // if inputs are being signed with SIGHASH_NONE, we don't strictly need outputs\n    // .build() will fail, but .buildIncomplete() is OK\n    return (\n      this.__TX.outs.length === 0 &&\n      this.__INPUTS.some((input) => {\n        if (!input.signatures) return false;\n\n        return input.signatures.some((signature) => {\n          if (!signature) return false; // no signature, no issue\n          const hashType = signatureHashType(signature);\n          if (hashType & Transaction.SIGHASH_NONE) return false; // SIGHASH_NONE doesn't care about outputs\n          return true; // SIGHASH_* does care\n        });\n      })\n    );\n  }\n\n  private __canModifyOutputs(): boolean {\n    const nInputs = this.__TX.ins.length;\n    const nOutputs = this.__TX.outs.length;\n\n    return this.__INPUTS.every((input) => {\n      if (input.signatures === undefined) return true;\n\n      return input.signatures.every((signature) => {\n        if (!signature) return true;\n        const hashType = signatureHashType(signature);\n\n        const hashTypeMod = hashType & 0x1f;\n        if (hashTypeMod === Transaction.SIGHASH_NONE) return true;\n        if (hashTypeMod === Transaction.SIGHASH_SINGLE) {\n          // if SIGHASH_SINGLE is set, and nInputs > nOutputs\n          // some signatures would be invalidated by the addition\n          // of more outputs\n          return nInputs <= nOutputs;\n        }\n        return false;\n      });\n    });\n  }\n\n  private __overMaximumFees(bytes: number): boolean {\n    // not all inputs will have .value defined\n    const incoming = this.__INPUTS.reduce(\n      (a, x) => a + (typeof x.value !== 'undefined' ? BigInt(x.value) : BigInt(0)),\n      BigInt(0)\n    );\n\n    // but all outputs do, and if we have any input value\n    // we can immediately determine if the outputs are too small\n    const outgoing = this.__TX.outs.reduce((a, x) => a + BigInt((x as TxOutput<TNumber>).value), BigInt(0));\n    const fee = incoming - outgoing;\n    const feeRate = Number(fee) / bytes; // assume fee fits within number\n\n    return feeRate > this.maximumFeeRate;\n  }\n}\n\nfunction expandInput<TNumber extends number | bigint = number>(\n  scriptSig?: Buffer,\n  witnessStack: Buffer[] = [],\n  type?: string,\n  scriptPubKey?: Buffer\n): TxbInput<TNumber> {\n  if (scriptSig && scriptSig.length === 0 && witnessStack.length === 0) return {};\n  if (!type) {\n    let ssType: string | undefined = scriptSig ? classify.input(scriptSig, true) : undefined;\n    let wsType: string | undefined = classify.witness(witnessStack, true);\n    if (ssType === SCRIPT_TYPES.NONSTANDARD) ssType = undefined;\n    if (wsType === SCRIPT_TYPES.NONSTANDARD) wsType = undefined;\n    type = ssType || wsType;\n  }\n\n  switch (type) {\n    case SCRIPT_TYPES.P2WPKH: {\n      const { output, pubkey, signature } = payments.p2wpkh({\n        witness: witnessStack,\n      });\n\n      return {\n        prevOutScript: output,\n        prevOutType: SCRIPT_TYPES.P2WPKH,\n        pubkeys: [pubkey],\n        signatures: [signature],\n      };\n    }\n\n    case SCRIPT_TYPES.P2PKH: {\n      const { output, pubkey, signature } = payments.p2pkh({\n        input: scriptSig,\n      });\n\n      return {\n        prevOutScript: output,\n        prevOutType: SCRIPT_TYPES.P2PKH,\n        pubkeys: [pubkey],\n        signatures: [signature],\n      };\n    }\n\n    case SCRIPT_TYPES.P2PK: {\n      const { signature } = payments.p2pk({ input: scriptSig });\n\n      return {\n        prevOutType: SCRIPT_TYPES.P2PK,\n        pubkeys: [undefined],\n        signatures: [signature],\n      };\n    }\n\n    case SCRIPT_TYPES.P2MS: {\n      const { m, pubkeys, signatures } = payments.p2ms(\n        {\n          input: scriptSig,\n          output: scriptPubKey,\n        },\n        { allowIncomplete: true }\n      );\n\n      return {\n        prevOutType: SCRIPT_TYPES.P2MS,\n        pubkeys,\n        signatures,\n        maxSignatures: m,\n      };\n    }\n\n    case SCRIPT_TYPES.P2TR_NS: {\n      const { n, pubkeys, signatures } = p2trPayments.p2tr_ns(\n        {\n          // Witness signatures are reverse of pubkeys, because it's a stack\n          signatures: witnessStack.length ? witnessStack.reverse() : undefined,\n          output: scriptPubKey,\n        },\n        { allowIncomplete: true, eccLib }\n      );\n\n      return {\n        prevOutType: SCRIPT_TYPES.P2TR_NS,\n        pubkeys,\n        signatures,\n        maxSignatures: n,\n      };\n    }\n  }\n\n  if (type === SCRIPT_TYPES.P2SH) {\n    const { output, redeem } = payments.p2sh({\n      input: scriptSig,\n      witness: witnessStack,\n    });\n\n    const outputType = classify.output(redeem!.output!);\n    const expanded = expandInput<TNumber>(redeem!.input!, redeem!.witness!, outputType, redeem!.output);\n    if (!expanded.prevOutType) return {};\n\n    return {\n      prevOutScript: output,\n      prevOutType: SCRIPT_TYPES.P2SH,\n      redeemScript: redeem!.output,\n      redeemScriptType: expanded.prevOutType,\n      witnessScript: expanded.witnessScript,\n      witnessScriptType: expanded.witnessScriptType,\n\n      pubkeys: expanded.pubkeys,\n      signatures: expanded.signatures,\n    };\n  }\n\n  if (type === SCRIPT_TYPES.P2WSH) {\n    const { output, redeem } = payments.p2wsh({\n      input: scriptSig,\n      witness: witnessStack,\n    });\n    const outputType = classify.output(redeem!.output!);\n    let expanded;\n    if (outputType === SCRIPT_TYPES.P2WPKH) {\n      expanded = expandInput<TNumber>(redeem!.input!, redeem!.witness!, outputType);\n    } else {\n      expanded = expandInput<TNumber>(bscript.compile(redeem!.witness!), [], outputType, redeem!.output);\n    }\n    if (!expanded.prevOutType) return {};\n\n    return {\n      prevOutScript: output,\n      prevOutType: SCRIPT_TYPES.P2WSH,\n      witnessScript: redeem!.output,\n      witnessScriptType: expanded.prevOutType,\n\n      pubkeys: expanded.pubkeys,\n      signatures: expanded.signatures,\n    };\n  }\n\n  if (type === SCRIPT_TYPES.P2TR) {\n    const parsedWitness = taproot.parseTaprootWitness(witnessStack);\n    if (parsedWitness.spendType === 'Key') {\n      // key path spend, nothing to expand\n      const { signature, annex } = parsedWitness;\n      return {\n        prevOutType: SCRIPT_TYPES.P2TR,\n        signatures: [signature],\n        annex,\n      };\n    } else {\n      // script path spend\n      const { tapscript, controlBlock, annex } = parsedWitness;\n      const prevOutScript = p2trPayments.p2tr(\n        {\n          redeems: [{ output: tapscript }],\n          redeemIndex: 0,\n          controlBlock,\n          annex,\n        },\n        { eccLib }\n      ).output;\n      const witnessScriptType = classify.output(tapscript);\n      const { pubkeys, signatures } = expandInput<TNumber>(\n        undefined,\n        parsedWitness.scriptSig,\n        witnessScriptType,\n        tapscript\n      );\n\n      return {\n        prevOutScript,\n        prevOutType: SCRIPT_TYPES.P2TR,\n        witnessScript: tapscript,\n        witnessScriptType,\n\n        controlBlock,\n        annex,\n\n        pubkeys,\n        signatures,\n      };\n    }\n  }\n\n  return {\n    prevOutType: SCRIPT_TYPES.NONSTANDARD,\n    prevOutScript: scriptSig,\n  };\n}\n\n// could be done in expandInput, but requires the original Transaction for hashForSignature\nfunction fixMultisigOrder<TNumber extends number | bigint = number>(\n  input: TxbInput<TNumber>,\n  transaction: Transaction<TNumber>,\n  vin: number,\n  prevOutputs?: TxOutput<TNumber>[]\n): void {\n  if (input.redeemScriptType !== SCRIPT_TYPES.P2MS || !input.redeemScript) return;\n  if (input.pubkeys!.length === input.signatures!.length) return;\n  const prevOutput = prevOutputs && prevOutputs[vin];\n\n  const unmatched = input.signatures!.concat();\n\n  input.signatures = input.pubkeys!.map((pubKey) => {\n    const keyPair = ECPair.fromPublicKey(pubKey!);\n    let match: Buffer | undefined;\n\n    // check for a signature\n    unmatched.some((signature, i) => {\n      // skip if undefined || OP_0\n      if (!signature) return false;\n\n      // TODO: avoid O(n) hashForSignature\n      const parsed = bscript.signature.decode(signature);\n      const hash = transaction.hashForSignature(vin, input.redeemScript!, parsed.hashType, prevOutput?.value);\n\n      // skip if signature does not match pubKey\n      if (!keyPair.verify(hash, parsed.signature)) return false;\n\n      // remove matched signature from unmatched\n      unmatched[i] = undefined;\n      match = signature;\n\n      return true;\n    });\n\n    return match;\n  });\n}\n\nfunction expandOutput(script: Buffer, ourPubKey?: Buffer, controlBlock?: Buffer): TxbOutput {\n  typeforce(types.Buffer, script);\n  const type = classify.output(script);\n\n  switch (type) {\n    case SCRIPT_TYPES.P2PKH: {\n      if (!ourPubKey) return { type };\n\n      // does our hash160(pubKey) match the output scripts?\n      const pkh1 = payments.p2pkh({ output: script }).hash;\n      const pkh2 = bcrypto.hash160(ourPubKey);\n      if (!pkh1!.equals(pkh2)) return { type };\n\n      return {\n        type,\n        pubkeys: [ourPubKey],\n        signatures: [undefined],\n      };\n    }\n\n    case SCRIPT_TYPES.P2WPKH: {\n      if (!ourPubKey) return { type };\n\n      // does our hash160(pubKey) match the output scripts?\n      const wpkh1 = payments.p2wpkh({ output: script }).hash;\n      const wpkh2 = bcrypto.hash160(ourPubKey);\n      if (!wpkh1!.equals(wpkh2)) return { type };\n\n      return {\n        type,\n        pubkeys: [ourPubKey],\n        signatures: [undefined],\n      };\n    }\n\n    case SCRIPT_TYPES.P2TR: {\n      if (!ourPubKey) return { type };\n      // HACK ourPubKey to BIP340-style\n      if (ourPubKey.length === 33) ourPubKey = ourPubKey.slice(1);\n      // TODO: support multiple pubkeys\n      const p2tr = p2trPayments.p2tr({ pubkey: ourPubKey, controlBlock }, { eccLib });\n\n      // Does tweaked output for a single pubkey match?\n      if (!script.equals(p2tr.output!)) return { type };\n\n      // P2TR KeyPath, single key\n      return {\n        type,\n        pubkeys: [ourPubKey],\n        signatures: [undefined],\n      };\n    }\n\n    case SCRIPT_TYPES.P2TR_NS: {\n      const p2trNs = p2trPayments.p2tr_ns({ output: script }, { eccLib });\n      // P2TR ScriptPath\n      return {\n        type,\n        pubkeys: p2trNs.pubkeys,\n        signatures: p2trNs.pubkeys!.map((): undefined => undefined),\n        maxSignatures: p2trNs.pubkeys!.length,\n      };\n    }\n\n    case SCRIPT_TYPES.P2PK: {\n      const p2pk = payments.p2pk({ output: script });\n      return {\n        type,\n        pubkeys: [p2pk.pubkey],\n        signatures: [undefined],\n      };\n    }\n\n    case SCRIPT_TYPES.P2MS: {\n      const p2ms = payments.p2ms({ output: script });\n      return {\n        type,\n        pubkeys: p2ms.pubkeys,\n        signatures: p2ms.pubkeys!.map((): undefined => undefined),\n        maxSignatures: p2ms.m,\n      };\n    }\n  }\n\n  return { type };\n}\n\nfunction prepareInput<TNumber extends number | bigint = number>(\n  input: TxbInput<TNumber>,\n  ourPubKey: Buffer,\n  redeemScript?: Buffer,\n  witnessScript?: Buffer,\n  controlBlock?: Buffer,\n  annex?: Buffer\n): TxbInput<TNumber> {\n  if (redeemScript && witnessScript) {\n    const p2wsh = payments.p2wsh({\n      redeem: { output: witnessScript },\n    }) as Payment;\n    const p2wshAlt = payments.p2wsh({ output: redeemScript }) as Payment;\n    const p2sh = payments.p2sh({ redeem: { output: redeemScript } }) as Payment;\n    const p2shAlt = payments.p2sh({ redeem: p2wsh }) as Payment;\n\n    // enforces P2SH(P2WSH(...))\n    if (!p2wsh.hash!.equals(p2wshAlt.hash!)) throw new Error('Witness script inconsistent with prevOutScript');\n    if (!p2sh.hash!.equals(p2shAlt.hash!)) throw new Error('Redeem script inconsistent with prevOutScript');\n\n    const expanded = expandOutput(p2wsh.redeem!.output!, ourPubKey);\n    if (!expanded.pubkeys) {\n      throw new Error(expanded.type + ' not supported as witnessScript (' + bscript.toASM(witnessScript) + ')');\n    }\n    if (input.signatures && input.signatures.some((x) => x !== undefined)) {\n      expanded.signatures = input.signatures;\n    }\n\n    const signScript = witnessScript;\n    if (expanded.type === SCRIPT_TYPES.P2WPKH) throw new Error('P2SH(P2WSH(P2WPKH)) is a consensus failure');\n\n    return {\n      redeemScript,\n      redeemScriptType: SCRIPT_TYPES.P2WSH,\n\n      witnessScript,\n      witnessScriptType: expanded.type,\n\n      prevOutType: SCRIPT_TYPES.P2SH,\n      prevOutScript: p2sh.output,\n\n      witnessVersion: 0,\n      signScript,\n      signType: expanded.type,\n\n      pubkeys: expanded.pubkeys,\n      signatures: expanded.signatures,\n      maxSignatures: expanded.maxSignatures,\n    };\n  }\n\n  if (redeemScript) {\n    const p2sh = payments.p2sh({ redeem: { output: redeemScript } }) as Payment;\n\n    if (input.prevOutScript) {\n      let p2shAlt;\n      try {\n        p2shAlt = payments.p2sh({ output: input.prevOutScript }) as Payment;\n      } catch (e) {\n        throw new Error('PrevOutScript must be P2SH');\n      }\n      if (!p2sh.hash!.equals(p2shAlt.hash!)) throw new Error('Redeem script inconsistent with prevOutScript');\n    }\n\n    const expanded = expandOutput(p2sh.redeem!.output!, ourPubKey);\n    if (!expanded.pubkeys) {\n      throw new Error(expanded.type + ' not supported as redeemScript (' + bscript.toASM(redeemScript) + ')');\n    }\n    if (input.signatures && input.signatures.some((x) => x !== undefined)) {\n      expanded.signatures = input.signatures;\n    }\n\n    let signScript = redeemScript;\n    if (expanded.type === SCRIPT_TYPES.P2WPKH) {\n      signScript = payments.p2pkh({ pubkey: expanded.pubkeys[0] }).output!;\n    }\n\n    return {\n      redeemScript,\n      redeemScriptType: expanded.type,\n\n      prevOutType: SCRIPT_TYPES.P2SH,\n      prevOutScript: p2sh.output,\n\n      witnessVersion: expanded.type === SCRIPT_TYPES.P2WPKH ? 0 : undefined,\n      signScript,\n      signType: expanded.type,\n\n      pubkeys: expanded.pubkeys,\n      signatures: expanded.signatures,\n      maxSignatures: expanded.maxSignatures,\n    };\n  }\n\n  if (witnessScript && controlBlock) {\n    // P2TR ScriptPath\n    /* tslint:disable-next-line:no-shadowed-variable */\n    let prevOutScript = input.prevOutScript;\n    if (!prevOutScript) {\n      prevOutScript = p2trPayments.p2tr(\n        {\n          redeems: [{ output: witnessScript }],\n          redeemIndex: 0,\n          controlBlock,\n          annex,\n        },\n        { eccLib }\n      ).output;\n    }\n\n    const expanded = expandOutput(witnessScript, ourPubKey);\n    if (!expanded.pubkeys) {\n      throw new Error(expanded.type + ' not supported as witnessScript (' + bscript.toASM(witnessScript) + ')');\n    }\n    if (input.signatures && input.signatures.some((x) => x !== undefined)) {\n      expanded.signatures = input.signatures;\n    }\n\n    return {\n      witnessScript,\n      witnessScriptType: expanded.type,\n\n      prevOutType: SCRIPT_TYPES.P2TR,\n      prevOutScript,\n\n      witnessVersion: 1,\n      signScript: witnessScript,\n      signType: expanded.type,\n\n      pubkeys: expanded.pubkeys,\n      signatures: expanded.signatures,\n      maxSignatures: expanded.maxSignatures,\n\n      controlBlock,\n      annex,\n    };\n  }\n\n  if (witnessScript) {\n    const p2wsh = payments.p2wsh({ redeem: { output: witnessScript } });\n\n    if (input.prevOutScript) {\n      const p2wshAlt = payments.p2wsh({ output: input.prevOutScript });\n      if (!p2wsh.hash!.equals(p2wshAlt.hash!)) throw new Error('Witness script inconsistent with prevOutScript');\n    }\n\n    const expanded = expandOutput(p2wsh.redeem!.output!, ourPubKey);\n    if (!expanded.pubkeys) {\n      throw new Error(expanded.type + ' not supported as witnessScript (' + bscript.toASM(witnessScript) + ')');\n    }\n    if (input.signatures && input.signatures.some((x) => x !== undefined)) {\n      expanded.signatures = input.signatures;\n    }\n\n    const signScript = witnessScript;\n    if (expanded.type === SCRIPT_TYPES.P2WPKH) throw new Error('P2WSH(P2WPKH) is a consensus failure');\n\n    return {\n      witnessScript,\n      witnessScriptType: expanded.type,\n\n      prevOutType: SCRIPT_TYPES.P2WSH,\n      prevOutScript: p2wsh.output,\n\n      witnessVersion: 0,\n      signScript,\n      signType: expanded.type,\n\n      pubkeys: expanded.pubkeys,\n      signatures: expanded.signatures,\n      maxSignatures: expanded.maxSignatures,\n    };\n  }\n\n  if (input.prevOutType && input.prevOutScript) {\n    // embedded scripts are not possible without extra information\n    if (input.prevOutType === SCRIPT_TYPES.P2SH) {\n      throw new Error('PrevOutScript is ' + input.prevOutType + ', requires redeemScript');\n    }\n    if (input.prevOutType === SCRIPT_TYPES.P2WSH) {\n      throw new Error('PrevOutScript is ' + input.prevOutType + ', requires witnessScript');\n    }\n\n    const expanded = expandOutput(input.prevOutScript, ourPubKey);\n    if (!expanded.pubkeys) {\n      throw new Error(expanded.type + ' not supported (' + bscript.toASM(input.prevOutScript) + ')');\n    }\n    if (input.signatures && input.signatures.some((x) => x !== undefined)) {\n      expanded.signatures = input.signatures;\n    }\n\n    let signScript = input.prevOutScript;\n    if (expanded.type === SCRIPT_TYPES.P2WPKH) {\n      signScript = payments.p2pkh({ pubkey: expanded.pubkeys[0] }).output as Buffer;\n    }\n\n    let witnessVersion;\n    if (expanded.type === SCRIPT_TYPES.P2WPKH) {\n      witnessVersion = 0;\n    } else if (expanded.type === SCRIPT_TYPES.P2TR) {\n      witnessVersion = 1;\n    }\n\n    return {\n      prevOutType: expanded.type,\n      prevOutScript: input.prevOutScript,\n\n      witnessVersion,\n      signScript,\n      signType: expanded.type,\n\n      pubkeys: expanded.pubkeys,\n      signatures: expanded.signatures,\n      maxSignatures: expanded.maxSignatures,\n    };\n  }\n\n  const prevOutScript = payments.p2pkh({ pubkey: ourPubKey }).output;\n  return {\n    prevOutType: SCRIPT_TYPES.P2PKH,\n    prevOutScript,\n\n    signScript: prevOutScript,\n    signType: SCRIPT_TYPES.P2PKH,\n\n    pubkeys: [ourPubKey],\n    signatures: [undefined],\n  };\n}\n\nfunction build<TNumber extends number | bigint = number>(\n  type: string,\n  input: TxbInput<TNumber>,\n  allowIncomplete?: boolean\n): Payment | undefined {\n  const pubkeys = (input.pubkeys || []) as Buffer[];\n  let signatures = (input.signatures || []) as Buffer[];\n\n  switch (type) {\n    case SCRIPT_TYPES.P2PKH: {\n      if (pubkeys.length === 0) break;\n      if (signatures.length === 0) break;\n\n      return payments.p2pkh({ pubkey: pubkeys[0], signature: signatures[0] });\n    }\n    case SCRIPT_TYPES.P2WPKH: {\n      if (pubkeys.length === 0) break;\n      if (signatures.length === 0) break;\n\n      return payments.p2wpkh({ pubkey: pubkeys[0], signature: signatures[0] });\n    }\n    case SCRIPT_TYPES.P2PK: {\n      if (pubkeys.length === 0) break;\n      if (signatures.length === 0) break;\n\n      return payments.p2pk({ signature: signatures[0] });\n    }\n    case SCRIPT_TYPES.P2MS: {\n      const m = input.maxSignatures;\n      if (allowIncomplete) {\n        signatures = signatures.map((x) => x || ops.OP_0);\n      } else {\n        signatures = signatures.filter((x) => x);\n      }\n\n      // if the transaction is not not complete (complete), or if signatures.length === m, validate\n      // otherwise, the number of OP_0's may be >= m, so don't validate (boo)\n      const validate = !allowIncomplete || m === signatures.length;\n      return payments.p2ms({ m, pubkeys, signatures }, { allowIncomplete, validate });\n    }\n    case SCRIPT_TYPES.P2SH: {\n      const redeem = build<TNumber>(input.redeemScriptType!, input, allowIncomplete);\n      if (!redeem) return;\n\n      return payments.p2sh({\n        redeem: {\n          output: redeem.output || input.redeemScript,\n          input: redeem.input,\n          witness: redeem.witness,\n        },\n      });\n    }\n    case SCRIPT_TYPES.P2WSH: {\n      const redeem = build<TNumber>(input.witnessScriptType!, input, allowIncomplete);\n      if (!redeem) return;\n\n      return payments.p2wsh({\n        redeem: {\n          output: input.witnessScript,\n          input: redeem.input,\n          witness: redeem.witness,\n        },\n      });\n    }\n    case SCRIPT_TYPES.P2TR: {\n      if (input.witnessScriptType === SCRIPT_TYPES.P2TR_NS) {\n        // ScriptPath\n        const redeem = build<TNumber>(input.witnessScriptType!, input, allowIncomplete);\n        return p2trPayments.p2tr(\n          {\n            output: input.prevOutScript,\n            controlBlock: input.controlBlock,\n            annex: input.annex,\n            redeems: [redeem!],\n            redeemIndex: 0,\n          },\n          { eccLib }\n        );\n      }\n\n      // KeyPath\n      if (signatures.length === 0) break;\n\n      return p2trPayments.p2tr({ pubkeys, signature: signatures[0] }, { eccLib });\n    }\n    case SCRIPT_TYPES.P2TR_NS: {\n      const m = input.maxSignatures;\n      if (allowIncomplete) {\n        signatures = signatures.map((x) => x || ops.OP_0);\n      } else {\n        signatures = signatures.filter((x) => x);\n      }\n\n      // if the transaction is not not complete (complete), or if signatures.length === m, validate\n      // otherwise, the number of OP_0's may be >= m, so don't validate (boo)\n      const validate = !allowIncomplete || m === signatures.length;\n      return p2trPayments.p2tr_ns({ pubkeys, signatures }, { allowIncomplete, validate, eccLib });\n    }\n  }\n}\n\nfunction canSign<TNumber extends number | bigint = number>(input: TxbInput<TNumber>): boolean {\n  return (\n    input.signScript !== undefined &&\n    input.signType !== undefined &&\n    input.pubkeys !== undefined &&\n    input.signatures !== undefined &&\n    input.signatures.length === input.pubkeys.length &&\n    input.pubkeys.length > 0 &&\n    (input.witnessVersion === undefined || input.value !== undefined)\n  );\n}\n\nfunction signatureHashType(buffer: Buffer): number {\n  if (bscript.isCanonicalSchnorrSignature(buffer) && buffer.length === 64) {\n    return Transaction.SIGHASH_DEFAULT;\n  }\n  return buffer.readUInt8(buffer.length - 1);\n}\n\nfunction checkSignArgs<TNumber extends number | bigint = number>(\n  inputs: Array<TxbInput<TNumber>>,\n  signParams: TxbSignArg<TNumber>\n): void {\n  if (!PREVOUT_TYPES.has(signParams.prevOutScriptType)) {\n    throw new TypeError(`Unknown prevOutScriptType \"${signParams.prevOutScriptType}\"`);\n  }\n  tfMessage(typeforce.Number, signParams.vin, `sign must include vin parameter as Number (input index)`);\n  tfMessage(tfFullSigner, signParams.keyPair, `sign must include keyPair parameter as Signer interface`);\n  tfMessage(typeforce.maybe(typeforce.Number), signParams.hashType, `sign hashType parameter must be a number`);\n  const prevOutType = (inputs[signParams.vin] || []).prevOutType;\n  const posType = signParams.prevOutScriptType;\n  switch (posType) {\n    case 'p2pkh':\n      if (prevOutType && prevOutType !== 'pubkeyhash') {\n        throw new TypeError(`input #${signParams.vin} is not of type p2pkh: ${prevOutType}`);\n      }\n      tfMessage(typeforce.value(undefined), signParams.witnessScript, `${posType} requires NO witnessScript`);\n      tfMessage(typeforce.value(undefined), signParams.redeemScript, `${posType} requires NO redeemScript`);\n      tfMessage(typeforce.value(undefined), signParams.witnessValue, `${posType} requires NO witnessValue`);\n      break;\n    case 'p2pk':\n      if (prevOutType && prevOutType !== 'pubkey') {\n        throw new TypeError(`input #${signParams.vin} is not of type p2pk: ${prevOutType}`);\n      }\n      tfMessage(typeforce.value(undefined), signParams.witnessScript, `${posType} requires NO witnessScript`);\n      tfMessage(typeforce.value(undefined), signParams.redeemScript, `${posType} requires NO redeemScript`);\n      tfMessage(typeforce.value(undefined), signParams.witnessValue, `${posType} requires NO witnessValue`);\n      break;\n    case 'p2wpkh':\n      if (prevOutType && prevOutType !== 'witnesspubkeyhash') {\n        throw new TypeError(`input #${signParams.vin} is not of type p2wpkh: ${prevOutType}`);\n      }\n      tfMessage(typeforce.value(undefined), signParams.witnessScript, `${posType} requires NO witnessScript`);\n      tfMessage(typeforce.value(undefined), signParams.redeemScript, `${posType} requires NO redeemScript`);\n      tfMessage(types.Satoshi, signParams.witnessValue, `${posType} requires witnessValue`);\n      break;\n    case 'p2ms':\n      if (prevOutType && prevOutType !== 'multisig') {\n        throw new TypeError(`input #${signParams.vin} is not of type p2ms: ${prevOutType}`);\n      }\n      tfMessage(typeforce.value(undefined), signParams.witnessScript, `${posType} requires NO witnessScript`);\n      tfMessage(typeforce.value(undefined), signParams.redeemScript, `${posType} requires NO redeemScript`);\n      tfMessage(typeforce.value(undefined), signParams.witnessValue, `${posType} requires NO witnessValue`);\n      break;\n    case 'p2sh-p2wpkh':\n      if (prevOutType && prevOutType !== 'scripthash') {\n        throw new TypeError(`input #${signParams.vin} is not of type p2sh-p2wpkh: ${prevOutType}`);\n      }\n      tfMessage(typeforce.value(undefined), signParams.witnessScript, `${posType} requires NO witnessScript`);\n      tfMessage(typeforce.Buffer, signParams.redeemScript, `${posType} requires redeemScript`);\n      tfMessage(types.Satoshi, signParams.witnessValue, `${posType} requires witnessValue`);\n      break;\n    case 'p2sh-p2ms':\n    case 'p2sh-p2pk':\n    case 'p2sh-p2pkh':\n      if (prevOutType && prevOutType !== 'scripthash') {\n        throw new TypeError(`input #${signParams.vin} is not of type ${posType}: ${prevOutType}`);\n      }\n      tfMessage(typeforce.value(undefined), signParams.witnessScript, `${posType} requires NO witnessScript`);\n      tfMessage(typeforce.Buffer, signParams.redeemScript, `${posType} requires redeemScript`);\n      tfMessage(typeforce.value(undefined), signParams.witnessValue, `${posType} requires NO witnessValue`);\n      break;\n    case 'p2wsh-p2ms':\n    case 'p2wsh-p2pk':\n    case 'p2wsh-p2pkh':\n      if (prevOutType && prevOutType !== 'witnessscripthash') {\n        throw new TypeError(`input #${signParams.vin} is not of type ${posType}: ${prevOutType}`);\n      }\n      tfMessage(typeforce.Buffer, signParams.witnessScript, `${posType} requires witnessScript`);\n      tfMessage(typeforce.value(undefined), signParams.redeemScript, `${posType} requires NO redeemScript`);\n      tfMessage(types.Satoshi, signParams.witnessValue, `${posType} requires witnessValue`);\n      break;\n    case 'p2sh-p2wsh-p2ms':\n    case 'p2sh-p2wsh-p2pk':\n    case 'p2sh-p2wsh-p2pkh':\n      if (prevOutType && prevOutType !== 'scripthash') {\n        throw new TypeError(`input #${signParams.vin} is not of type ${posType}: ${prevOutType}`);\n      }\n      tfMessage(typeforce.Buffer, signParams.witnessScript, `${posType} requires witnessScript`);\n      tfMessage(typeforce.Buffer, signParams.redeemScript, `${posType} requires witnessScript`);\n      tfMessage(types.Satoshi, signParams.witnessValue, `${posType} requires witnessScript`);\n      break;\n    case 'p2tr':\n      if (prevOutType && prevOutType !== 'taproot') {\n        throw new TypeError(`input #${signParams.vin} is not of type ${posType}: ${prevOutType}`);\n      }\n      tfMessage(typeforce.value(undefined), signParams.witnessScript, `${posType} requires NO witnessScript`);\n      tfMessage(typeforce.value(undefined), signParams.redeemScript, `${posType} requires NO redeemScript`);\n      tfMessage(typeforce.value(undefined), signParams.witnessValue, `${posType} requires NO witnessValue`);\n      break;\n    case 'p2tr-p2ns':\n      if (prevOutType && prevOutType !== 'taproot') {\n        throw new TypeError(`input #${signParams.vin} is not of type ${posType}: ${prevOutType}`);\n      }\n      inputs[signParams.vin].prevOutType = inputs[signParams.vin].prevOutType || 'taproot';\n      tfMessage(typeforce.Buffer, signParams.witnessScript, `${posType} requires witnessScript`);\n      tfMessage(typeforce.Buffer, signParams.controlBlock, `${posType} requires controlBlock`);\n      tfMessage(typeforce.value(undefined), signParams.redeemScript, `${posType} requires NO redeemScript`);\n      break;\n  }\n}\n\nfunction trySign<TNumber extends number | bigint = number>({\n  input,\n  ourPubKey,\n  keyPair,\n  signatureHash,\n  hashType,\n  useLowR,\n  taptreeRoot,\n}: SigningData<TNumber>): void {\n  if (input.witnessVersion === 1 && ourPubKey.length === 33) ourPubKey = ourPubKey.slice(1);\n  // enforce in order signing of public keys\n  let signed = false;\n  for (const [i, pubKey] of input.pubkeys!.entries()) {\n    if (!ourPubKey.equals(pubKey!)) continue;\n    if (input.signatures![i] && input.signatures![i]!.length > 0) throw new Error('Signature already exists');\n\n    // TODO: add tests\n    if (ourPubKey.length !== 33 && input.witnessVersion === 0) {\n      throw new Error('BIP143 (Witness v0) inputs require compressed pubkeys');\n    } else if (ourPubKey.length !== 32 && input.witnessVersion === 1) {\n      throw new Error('BIP341 (Witness v1) inputs require x-only pubkeys');\n    }\n\n    if (input.witnessVersion === 1) {\n      if (!input.witnessScript) {\n        // FIXME: Workaround for not having proper tweaking support for key path\n        if (!keyPair.privateKey) {\n          throw new Error(`unexpected keypair`);\n        }\n        const privateKey = taproot.tapTweakPrivkey(eccLib, ourPubKey, keyPair.privateKey, taptreeRoot);\n        keyPair = ECPair.fromPrivateKey(Buffer.from(privateKey));\n      }\n      // https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki#common-signature-message\n      const signature = keyPair.signSchnorr(signatureHash);\n      // SIGHASH_DEFAULT is omitted from the signature\n      if (hashType === Transaction.SIGHASH_DEFAULT) {\n        input.signatures![i] = Buffer.from(signature);\n      } else {\n        input.signatures![i] = Buffer.concat([signature, Buffer.of(hashType)]);\n      }\n    } else {\n      const signature = keyPair.sign(signatureHash, useLowR);\n      input.signatures![i] = bscript.signature.encode(signature, hashType);\n    }\n    signed = true;\n  }\n\n  if (!signed) throw new Error('Key pair cannot sign for this input');\n}\n\ninterface SigningData<TNumber extends number | bigint = number> {\n  input: TxbInput<TNumber>;\n  ourPubKey: Buffer;\n  keyPair: Signer;\n  signatureHash: Buffer;\n  hashType: number;\n  useLowR: boolean;\n  taptreeRoot?: Buffer;\n}\n\ntype HashTypeCheck = (hashType: number) => boolean;\n\nfunction getSigningData<TNumber extends number | bigint = number>(\n  network: Network,\n  inputs: Array<TxbInput<TNumber>>,\n  needsOutputs: HashTypeCheck,\n  tx: Transaction<TNumber>,\n  signParams: number | TxbSignArg<TNumber>,\n  keyPair?: Signer,\n  redeemScript?: Buffer,\n  hashType?: number,\n  witnessValue?: TNumber,\n  witnessScript?: Buffer,\n  controlBlock?: Buffer,\n  annex?: Buffer,\n  useLowR?: boolean\n): SigningData<TNumber> {\n  let vin: number;\n  if (typeof signParams === 'number') {\n    console.warn(\n      'DEPRECATED: TransactionBuilder sign method arguments ' + 'will change in v6, please use the TxbSignArg interface'\n    );\n    vin = signParams;\n  } else if (typeof signParams === 'object') {\n    checkSignArgs<TNumber>(inputs, signParams);\n    ({ vin, keyPair, redeemScript, hashType, witnessValue, witnessScript, controlBlock, annex } = signParams);\n  } else {\n    throw new TypeError('TransactionBuilder sign first arg must be TxbSignArg or number');\n  }\n  if (keyPair === undefined) {\n    throw new Error('sign requires keypair');\n  }\n  if (!inputs[vin]) throw new Error('No input at index: ' + vin);\n\n  const input = inputs[vin];\n\n  // if redeemScript was previously provided, enforce consistency\n  if (input.redeemScript !== undefined && redeemScript && !input.redeemScript.equals(redeemScript)) {\n    throw new Error('Inconsistent redeemScript');\n  }\n\n  const ourPubKey = keyPair.publicKey || (keyPair.getPublicKey && keyPair.getPublicKey());\n  if (!canSign<TNumber>(input)) {\n    if (witnessValue !== undefined) {\n      if (input.value !== undefined && input.value !== witnessValue) {\n        throw new Error('Input did not match witnessValue');\n      }\n      typeforce(types.Satoshi, witnessValue);\n      input.value = witnessValue;\n    }\n\n    if (!canSign<TNumber>(input)) {\n      const prepared = prepareInput<TNumber>(input, ourPubKey, redeemScript, witnessScript, controlBlock, annex);\n\n      // updates inline\n      Object.assign(input, prepared);\n    }\n\n    if (!canSign<TNumber>(input)) throw Error(input.prevOutType + ' not supported');\n  }\n\n  // hashType can be 0 in Taproot, so can't use hashType || SIGHASH_ALL\n  if (input.witnessVersion === 1) {\n    hashType = hashType === undefined ? Transaction.SIGHASH_DEFAULT : hashType;\n  } else {\n    hashType = hashType || Transaction.SIGHASH_ALL;\n  }\n  if (needsOutputs(hashType)) throw new Error('Transaction needs outputs');\n\n  // TODO: This is not the best place to do this, but might stick with it until PSBT\n  let leafHash;\n  let taptreeRoot;\n  if (controlBlock && witnessScript) {\n    leafHash = taproot.getTapleafHash(eccLib, controlBlock, witnessScript);\n    taptreeRoot = taproot.getTaptreeRoot(eccLib, controlBlock, witnessScript, leafHash);\n  }\n\n  // ready to sign\n  let signatureHash: Buffer;\n  switch (input.witnessVersion) {\n    case undefined:\n      signatureHash = tx.hashForSignature(vin, input.signScript as Buffer, hashType, input.value);\n      break;\n    case 0:\n      signatureHash = tx.hashForWitnessV0(vin, input.signScript as Buffer, input.value as TNumber, hashType);\n      break;\n    case 1:\n      signatureHash = tx.hashForWitnessV1(\n        vin,\n        inputs.map(({ prevOutScript }) => prevOutScript as Buffer),\n        inputs.map(({ value }) => value as TNumber),\n        hashType,\n        leafHash\n      );\n      break;\n    default:\n      throw new TypeError('Unsupported witness version');\n  }\n\n  return {\n    input,\n    ourPubKey,\n    keyPair,\n    signatureHash,\n    hashType,\n    useLowR: !!useLowR,\n    taptreeRoot,\n  };\n}\n"]}