@btc-vision/bitcoin 6.3.1 → 6.3.3

package/build/psbt.js

@@ -0,0 +1,1307 @@
+import { Psbt as PsbtBase } from 'bip174';
+import * as varuint from 'bip174/src/lib/converter/varint.js';
+import { checkForInput, checkForOutput } from 'bip174/src/lib/utils.js';
+import { fromOutputScript, toOutputScript } from './address.js';
+import { cloneBuffer, reverseBuffer } from './bufferutils.js';
+import { hookSigner } from './hooks/HookedSigner.js';
+import { payments } from './index.js';
+import { bitcoin as btcNetwork } from './networks.js';
+import { tapleafHash } from './payments/bip341.js';
+import { checkTaprootInputFields, checkTaprootInputForSigs, checkTaprootOutputFields, isTaprootInput, serializeTaprootSignature, tapScriptFinalizer, toXOnly, } from './psbt/bip371.js';
+import { checkInputForSig, isP2MS, isP2PK, isP2PKH, isP2SHScript, isP2TR, isP2WPKH, isP2WSHScript, pubkeyInScript, witnessStackToScriptWitness, } from './psbt/psbtutils.js';
+import * as bscript from './script.js';
+import { Transaction } from './transaction.js';
+const DEFAULT_OPTS = {
+    network: btcNetwork,
+    maximumFeeRate: 5000,
+};
+export class Psbt {
+    constructor(opts = {}, data = new PsbtBase(new PsbtTransaction())) {
+        this.data = data;
+        this.opts = Object.assign({}, DEFAULT_OPTS, opts);
+        this.__CACHE = {
+            __NON_WITNESS_UTXO_TX_CACHE: [],
+            __NON_WITNESS_UTXO_BUF_CACHE: [],
+            __TX_IN_CACHE: {},
+            __TX: this.data.globalMap.unsignedTx.tx,
+            __UNSAFE_SIGN_NONSEGWIT: false,
+        };
+        if (this.data.inputs.length === 0)
+            this.setVersion(2);
+        const dpew = (obj, attr, enumerable, writable) => {
+            Object.defineProperty(obj, attr, {
+                enumerable,
+                writable,
+            });
+        };
+        dpew(this, '__CACHE', false, true);
+        dpew(this, 'opts', false, true);
+    }
+    get inputCount() {
+        return this.data.inputs.length;
+    }
+    get version() {
+        return this.__CACHE.__TX.version;
+    }
+    set version(version) {
+        this.setVersion(version);
+    }
+    get locktime() {
+        return this.__CACHE.__TX.locktime;
+    }
+    set locktime(locktime) {
+        this.setLocktime(locktime);
+    }
+    get txInputs() {
+        return this.__CACHE.__TX.ins.map((input) => ({
+            hash: cloneBuffer(input.hash),
+            index: input.index,
+            sequence: input.sequence,
+        }));
+    }
+    get txOutputs() {
+        return this.__CACHE.__TX.outs.map((output) => {
+            let address;
+            try {
+                address = fromOutputScript(output.script, this.opts.network);
+            }
+            catch (_) { }
+            return {
+                script: cloneBuffer(output.script),
+                value: output.value,
+                address,
+            };
+        });
+    }
+    static fromBase64(data, opts = {}) {
+        const buffer = Buffer.from(data, 'base64');
+        return this.fromBuffer(buffer, opts);
+    }
+    static fromHex(data, opts = {}) {
+        const buffer = Buffer.from(data, 'hex');
+        return this.fromBuffer(buffer, opts);
+    }
+    static fromBuffer(buffer, opts = {}) {
+        const psbtBase = PsbtBase.fromBuffer(buffer, transactionFromBuffer);
+        const psbt = new Psbt(opts, psbtBase);
+        checkTxForDupeIns(psbt.__CACHE.__TX, psbt.__CACHE);
+        return psbt;
+    }
+    combine(...those) {
+        this.data.combine(...those.map((o) => o.data));
+        return this;
+    }
+    clone() {
+        const res = Psbt.fromBuffer(this.data.toBuffer(), JSON.parse(JSON.stringify(this.opts)));
+        return res;
+    }
+    setMaximumFeeRate(satoshiPerByte) {
+        check32Bit(satoshiPerByte);
+        this.opts.maximumFeeRate = satoshiPerByte;
+    }
+    setVersion(version) {
+        check32Bit(version);
+        checkInputsForPartialSig(this.data.inputs, 'setVersion');
+        const c = this.__CACHE;
+        c.__TX.version = version;
+        c.__EXTRACTED_TX = undefined;
+        return this;
+    }
+    setLocktime(locktime) {
+        check32Bit(locktime);
+        checkInputsForPartialSig(this.data.inputs, 'setLocktime');
+        const c = this.__CACHE;
+        c.__TX.locktime = locktime;
+        c.__EXTRACTED_TX = undefined;
+        return this;
+    }
+    setInputSequence(inputIndex, sequence) {
+        check32Bit(sequence);
+        checkInputsForPartialSig(this.data.inputs, 'setInputSequence');
+        const c = this.__CACHE;
+        if (c.__TX.ins.length <= inputIndex) {
+            throw new Error('Input index too high');
+        }
+        c.__TX.ins[inputIndex].sequence = sequence;
+        c.__EXTRACTED_TX = undefined;
+        return this;
+    }
+    addInputs(inputDatas, checkPartialSigs = true) {
+        inputDatas.forEach((inputData) => this.addInput(inputData, checkPartialSigs));
+        return this;
+    }
+    addInput(inputData, checkPartialSigs = true) {
+        if (!inputData || inputData.hash === undefined || inputData.index === undefined) {
+            throw new Error(`Invalid arguments for Psbt.addInput. ` +
+                `Requires single object with at least [hash] and [index]`);
+        }
+        checkTaprootInputFields(inputData, inputData, 'addInput');
+        if (checkPartialSigs) {
+            checkInputsForPartialSig(this.data.inputs, 'addInput');
+        }
+        if (inputData.witnessScript)
+            checkInvalidP2WSH(inputData.witnessScript);
+        const c = this.__CACHE;
+        this.data.addInput(inputData);
+        const txIn = c.__TX.ins[c.__TX.ins.length - 1];
+        checkTxInputCache(c, txIn);
+        const inputIndex = this.data.inputs.length - 1;
+        const input = this.data.inputs[inputIndex];
+        if (input.nonWitnessUtxo) {
+            addNonWitnessTxCache(this.__CACHE, input, inputIndex);
+        }
+        c.__FEE = undefined;
+        c.__FEE_RATE = undefined;
+        c.__EXTRACTED_TX = undefined;
+        return this;
+    }
+    addOutputs(outputDatas) {
+        outputDatas.forEach((outputData) => this.addOutput(outputData));
+        return this;
+    }
+    addOutput(outputData) {
+        if (arguments.length > 1 ||
+            !outputData ||
+            outputData.value === undefined ||
+            (outputData.address === undefined && outputData.script === undefined)) {
+            throw new Error(`Invalid arguments for Psbt.addOutput. ` +
+                `Requires single object with at least [script or address] and [value]`);
+        }
+        checkInputsForPartialSig(this.data.inputs, 'addOutput');
+        const { address } = outputData;
+        if (typeof address === 'string') {
+            const { network } = this.opts;
+            const script = toOutputScript(address, network);
+            outputData = Object.assign({}, outputData, { script });
+        }
+        checkTaprootOutputFields(outputData, outputData, 'addOutput');
+        const c = this.__CACHE;
+        this.data.addOutput(outputData);
+        c.__FEE = undefined;
+        c.__FEE_RATE = undefined;
+        c.__EXTRACTED_TX = undefined;
+        return this;
+    }
+    extractTransaction(disableFeeCheck, disableOutputChecks) {
+        if (disableOutputChecks) {
+            this.data.inputs = this.data.inputs.filter((i) => !i.partialSig);
+        }
+        if (!this.data.inputs.every(isFinalized))
+            throw new Error('Not finalized');
+        const c = this.__CACHE;
+        if (!disableFeeCheck) {
+            checkFees(this, c, this.opts);
+        }
+        if (c.__EXTRACTED_TX)
+            return c.__EXTRACTED_TX;
+        const tx = c.__TX.clone();
+        inputFinalizeGetAmts(this.data.inputs, tx, c, true, disableOutputChecks);
+        return tx;
+    }
+    getFeeRate(disableOutputChecks = false) {
+        return getTxCacheValue('__FEE_RATE', 'fee rate', this.data.inputs, this.__CACHE, disableOutputChecks);
+    }
+    getFee(disableOutputChecks = false) {
+        return getTxCacheValue('__FEE', 'fee', this.data.inputs, this.__CACHE, disableOutputChecks);
+    }
+    finalizeAllInputs() {
+        checkForInput(this.data.inputs, 0);
+        range(this.data.inputs.length).forEach((idx) => this.finalizeInput(idx));
+        return this;
+    }
+    finalizeInput(inputIndex, finalScriptsFunc, canRunChecks) {
+        const input = checkForInput(this.data.inputs, inputIndex);
+        if (isTaprootInput(input)) {
+            return this._finalizeTaprootInput(inputIndex, input, undefined, finalScriptsFunc);
+        }
+        return this._finalizeInput(inputIndex, input, finalScriptsFunc, canRunChecks ?? true);
+    }
+    finalizeTaprootInput(inputIndex, tapLeafHashToFinalize, finalScriptsFunc = tapScriptFinalizer) {
+        const input = checkForInput(this.data.inputs, inputIndex);
+        if (isTaprootInput(input))
+            return this._finalizeTaprootInput(inputIndex, input, tapLeafHashToFinalize, finalScriptsFunc);
+        throw new Error(`Cannot finalize input #${inputIndex}. Not Taproot.`);
+    }
+    getInputType(inputIndex) {
+        const input = checkForInput(this.data.inputs, inputIndex);
+        const script = getScriptFromUtxo(inputIndex, input, this.__CACHE);
+        const result = getMeaningfulScript(script, inputIndex, 'input', input.redeemScript || redeemFromFinalScriptSig(input.finalScriptSig), input.witnessScript || redeemFromFinalWitnessScript(input.finalScriptWitness));
+        const type = result.type === 'raw' ? '' : result.type + '-';
+        const mainType = classifyScript(result.meaningfulScript);
+        return (type + mainType);
+    }
+    inputHasPubkey(inputIndex, pubkey) {
+        const input = checkForInput(this.data.inputs, inputIndex);
+        return pubkeyInInput(pubkey, input, inputIndex, this.__CACHE);
+    }
+    inputHasHDKey(inputIndex, root) {
+        const input = checkForInput(this.data.inputs, inputIndex);
+        const derivationIsMine = bip32DerivationIsMine(root);
+        return !!input.bip32Derivation && input.bip32Derivation.some(derivationIsMine);
+    }
+    outputHasPubkey(outputIndex, pubkey) {
+        const output = checkForOutput(this.data.outputs, outputIndex);
+        return pubkeyInOutput(pubkey, output, outputIndex, this.__CACHE);
+    }
+    outputHasHDKey(outputIndex, root) {
+        const output = checkForOutput(this.data.outputs, outputIndex);
+        const derivationIsMine = bip32DerivationIsMine(root);
+        return !!output.bip32Derivation && output.bip32Derivation.some(derivationIsMine);
+    }
+    validateSignaturesOfAllInputs(validator) {
+        checkForInput(this.data.inputs, 0);
+        const results = range(this.data.inputs.length).map((idx) => this.validateSignaturesOfInput(idx, validator));
+        return results.reduce((final, res) => res === true && final, true);
+    }
+    validateSignaturesOfInput(inputIndex, validator, pubkey) {
+        const input = this.data.inputs[inputIndex];
+        if (isTaprootInput(input))
+            return this.validateSignaturesOfTaprootInput(inputIndex, validator, pubkey);
+        return this._validateSignaturesOfInput(inputIndex, validator, pubkey);
+    }
+    signAllInputsHD(hdKeyPair, sighashTypes = [Transaction.SIGHASH_ALL]) {
+        if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
+            throw new Error('Need HDSigner to sign input');
+        }
+        const results = [];
+        for (const i of range(this.data.inputs.length)) {
+            try {
+                this.signInputHD(i, hdKeyPair, sighashTypes);
+                results.push(true);
+            }
+            catch (err) {
+                results.push(false);
+            }
+        }
+        if (results.every((v) => v === false)) {
+            throw new Error('No inputs were signed');
+        }
+        return this;
+    }
+    signAllInputsHDAsync(hdKeyPair, sighashTypes = [Transaction.SIGHASH_ALL]) {
+        return new Promise((resolve, reject) => {
+            if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
+                return reject(new Error('Need HDSigner to sign input'));
+            }
+            const results = [];
+            const promises = [];
+            for (const i of range(this.data.inputs.length)) {
+                promises.push(this.signInputHDAsync(i, hdKeyPair, sighashTypes).then(() => {
+                    results.push(true);
+                }, () => {
+                    results.push(false);
+                }));
+            }
+            return Promise.all(promises).then(() => {
+                if (results.every((v) => v === false)) {
+                    return reject(new Error('No inputs were signed'));
+                }
+                resolve();
+            });
+        });
+    }
+    signInputHD(inputIndex, hdKeyPair, sighashTypes = [Transaction.SIGHASH_ALL]) {
+        if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
+            throw new Error('Need HDSigner to sign input');
+        }
+        const signers = getSignersFromHD(inputIndex, this.data.inputs, hdKeyPair);
+        signers.forEach((signer) => this.signInput(inputIndex, signer, sighashTypes));
+        return this;
+    }
+    signInputHDAsync(inputIndex, hdKeyPair, sighashTypes = [Transaction.SIGHASH_ALL]) {
+        return new Promise((resolve, reject) => {
+            if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
+                return reject(new Error('Need HDSigner to sign input'));
+            }
+            const signers = getSignersFromHD(inputIndex, this.data.inputs, hdKeyPair);
+            const promises = signers.map((signer) => this.signInputAsync(inputIndex, signer, sighashTypes));
+            return Promise.all(promises)
+                .then(() => {
+                resolve();
+            })
+                .catch(reject);
+        });
+    }
+    signAllInputs(keyPair, sighashTypes) {
+        if (!keyPair || !keyPair.publicKey)
+            throw new Error('Need Signer to sign input');
+        const results = [];
+        for (const i of range(this.data.inputs.length)) {
+            try {
+                this.signInput(i, keyPair, sighashTypes);
+                results.push(true);
+            }
+            catch (err) {
+                results.push(false);
+            }
+        }
+        if (results.every((v) => v === false)) {
+            throw new Error('No inputs were signed');
+        }
+        return this;
+    }
+    signAllInputsAsync(keyPair, sighashTypes) {
+        return new Promise((resolve, reject) => {
+            if (!keyPair || !keyPair.publicKey)
+                return reject(new Error('Need Signer to sign input'));
+            const results = [];
+            const promises = [];
+            for (const [i] of this.data.inputs.entries()) {
+                promises.push(this.signInputAsync(i, keyPair, sighashTypes).then(() => {
+                    results.push(true);
+                }, () => {
+                    results.push(false);
+                }));
+            }
+            return Promise.all(promises).then(() => {
+                if (results.every((v) => v === false)) {
+                    return reject(new Error('No inputs were signed'));
+                }
+                resolve();
+            });
+        });
+    }
+    signInput(inputIndex, keyPair, sighashTypes) {
+        if (!keyPair || !keyPair.publicKey) {
+            throw new Error('Need Signer to sign input');
+        }
+        const input = checkForInput(this.data.inputs, inputIndex);
+        if (isTaprootInput(input)) {
+            return this._signTaprootInput(inputIndex, input, keyPair, undefined, sighashTypes);
+        }
+        return this._signInput(inputIndex, keyPair, sighashTypes);
+    }
+    signTaprootInput(inputIndex, keyPair, tapLeafHashToSign, sighashTypes) {
+        if (!keyPair || !keyPair.publicKey) {
+            throw new Error('Need Signer to sign input');
+        }
+        const input = checkForInput(this.data.inputs, inputIndex);
+        if (isTaprootInput(input)) {
+            return this._signTaprootInput(inputIndex, input, keyPair, tapLeafHashToSign, sighashTypes);
+        }
+        throw new Error(`Input #${inputIndex} is not of type Taproot.`);
+    }
+    signInputAsync(inputIndex, keyPair, sighashTypes) {
+        return Promise.resolve().then(() => {
+            if (!keyPair || !keyPair.publicKey)
+                throw new Error('Need Signer to sign input');
+            const input = checkForInput(this.data.inputs, inputIndex);
+            if (isTaprootInput(input))
+                return this._signTaprootInputAsync(inputIndex, input, keyPair, undefined, sighashTypes);
+            return this._signInputAsync(inputIndex, keyPair, sighashTypes);
+        });
+    }
+    signTaprootInputAsync(inputIndex, keyPair, tapLeafHash, sighashTypes) {
+        return Promise.resolve().then(() => {
+            if (!keyPair || !keyPair.publicKey)
+                throw new Error('Need Signer to sign input');
+            const input = checkForInput(this.data.inputs, inputIndex);
+            if (isTaprootInput(input))
+                return this._signTaprootInputAsync(inputIndex, input, keyPair, tapLeafHash, sighashTypes);
+            throw new Error(`Input #${inputIndex} is not of type Taproot.`);
+        });
+    }
+    toBuffer() {
+        checkCache(this.__CACHE);
+        return this.data.toBuffer();
+    }
+    toHex() {
+        checkCache(this.__CACHE);
+        return this.data.toHex();
+    }
+    toBase64() {
+        checkCache(this.__CACHE);
+        return this.data.toBase64();
+    }
+    updateGlobal(updateData) {
+        this.data.updateGlobal(updateData);
+        return this;
+    }
+    updateInput(inputIndex, updateData) {
+        if (updateData.witnessScript)
+            checkInvalidP2WSH(updateData.witnessScript);
+        checkTaprootInputFields(this.data.inputs[inputIndex], updateData, 'updateInput');
+        this.data.updateInput(inputIndex, updateData);
+        if (updateData.nonWitnessUtxo) {
+            addNonWitnessTxCache(this.__CACHE, this.data.inputs[inputIndex], inputIndex);
+        }
+        return this;
+    }
+    updateOutput(outputIndex, updateData) {
+        const outputData = this.data.outputs[outputIndex];
+        checkTaprootOutputFields(outputData, updateData, 'updateOutput');
+        this.data.updateOutput(outputIndex, updateData);
+        return this;
+    }
+    addUnknownKeyValToGlobal(keyVal) {
+        this.data.addUnknownKeyValToGlobal(keyVal);
+        return this;
+    }
+    addUnknownKeyValToInput(inputIndex, keyVal) {
+        this.data.addUnknownKeyValToInput(inputIndex, keyVal);
+        return this;
+    }
+    addUnknownKeyValToOutput(outputIndex, keyVal) {
+        this.data.addUnknownKeyValToOutput(outputIndex, keyVal);
+        return this;
+    }
+    clearFinalizedInput(inputIndex) {
+        this.data.clearFinalizedInput(inputIndex);
+        return this;
+    }
+    checkTaprootHashesForSig(inputIndex, input, keyPair, tapLeafHashToSign, allowedSighashTypes) {
+        if (typeof keyPair.signSchnorr !== 'function')
+            throw new Error(`Need Schnorr Signer to sign taproot input #${inputIndex}.`);
+        const hashesForSig = getTaprootHashesForSig(inputIndex, input, this.data.inputs, keyPair.publicKey, this.__CACHE, tapLeafHashToSign, allowedSighashTypes);
+        if (!hashesForSig || !hashesForSig.length)
+            throw new Error(`Can not sign for input #${inputIndex} with the key ${keyPair.publicKey.toString('hex')}`);
+        return hashesForSig;
+    }
+    _finalizeInput(inputIndex, input, finalScriptsFunc = getFinalScripts, canRunChecks = true) {
+        const { script, isP2SH, isP2WSH, isSegwit } = getScriptFromInput(inputIndex, input, this.__CACHE);
+        if (!script)
+            throw new Error(`No script found for input #${inputIndex}`);
+        checkPartialSigSighashes(input);
+        const { finalScriptSig, finalScriptWitness } = finalScriptsFunc(inputIndex, input, script, isSegwit, isP2SH, isP2WSH, canRunChecks);
+        if (finalScriptSig)
+            this.data.updateInput(inputIndex, { finalScriptSig });
+        if (finalScriptWitness)
+            this.data.updateInput(inputIndex, { finalScriptWitness });
+        if (!finalScriptSig && !finalScriptWitness)
+            throw new Error(`Unknown error finalizing input #${inputIndex}`);
+        this.data.clearFinalizedInput(inputIndex);
+        return this;
+    }
+    _finalizeTaprootInput(inputIndex, input, tapLeafHashToFinalize, finalScriptsFunc = tapScriptFinalizer) {
+        if (!input.witnessUtxo)
+            throw new Error(`Cannot finalize input #${inputIndex}. Missing witness utxo.`);
+        if (input.tapKeySig) {
+            const payment = payments.p2tr({
+                output: input.witnessUtxo.script,
+                signature: input.tapKeySig,
+            });
+            const finalScriptWitness = witnessStackToScriptWitness(payment.witness);
+            this.data.updateInput(inputIndex, { finalScriptWitness });
+        }
+        else {
+            const { finalScriptWitness } = finalScriptsFunc(inputIndex, input, tapLeafHashToFinalize);
+            this.data.updateInput(inputIndex, { finalScriptWitness });
+        }
+        this.data.clearFinalizedInput(inputIndex);
+        return this;
+    }
+    _validateSignaturesOfInput(inputIndex, validator, pubkey) {
+        const input = this.data.inputs[inputIndex];
+        const partialSig = (input || {}).partialSig;
+        if (!input || !partialSig || partialSig.length < 1)
+            throw new Error('No signatures to validate');
+        if (typeof validator !== 'function')
+            throw new Error('Need validator function to validate signatures');
+        const mySigs = pubkey ? partialSig.filter((sig) => sig.pubkey.equals(pubkey)) : partialSig;
+        if (mySigs.length < 1)
+            throw new Error('No signatures for this pubkey');
+        const results = [];
+        let hashCache;
+        let scriptCache;
+        let sighashCache;
+        for (const pSig of mySigs) {
+            const sig = bscript.signature.decode(pSig.signature);
+            const { hash, script } = sighashCache !== sig.hashType
+                ? getHashForSig(inputIndex, Object.assign({}, input, {
+                    sighashType: sig.hashType,
+                }), this.__CACHE, true)
+                : { hash: hashCache, script: scriptCache };
+            sighashCache = sig.hashType;
+            hashCache = hash;
+            scriptCache = script;
+            checkScriptForPubkey(pSig.pubkey, script, 'verify');
+            results.push(validator(pSig.pubkey, hash, sig.signature));
+        }
+        return results.every((res) => res === true);
+    }
+    validateSignaturesOfTaprootInput(inputIndex, validator, pubkey) {
+        const input = this.data.inputs[inputIndex];
+        const tapKeySig = (input || {}).tapKeySig;
+        const tapScriptSig = (input || {}).tapScriptSig;
+        if (!input && !tapKeySig && !(tapScriptSig && !tapScriptSig.length))
+            throw new Error('No signatures to validate');
+        if (typeof validator !== 'function')
+            throw new Error('Need validator function to validate signatures');
+        pubkey = pubkey && toXOnly(pubkey);
+        const allHashses = pubkey
+            ? getTaprootHashesForSig(inputIndex, input, this.data.inputs, pubkey, this.__CACHE)
+            : getAllTaprootHashesForSig(inputIndex, input, this.data.inputs, this.__CACHE);
+        if (!allHashses.length)
+            throw new Error('No signatures for this pubkey');
+        const tapKeyHash = allHashses.find((h) => !h.leafHash);
+        let validationResultCount = 0;
+        if (tapKeySig && tapKeyHash) {
+            const isValidTapkeySig = validator(tapKeyHash.pubkey, tapKeyHash.hash, trimTaprootSig(tapKeySig));
+            if (!isValidTapkeySig)
+                return false;
+            validationResultCount++;
+        }
+        if (tapScriptSig) {
+            for (const tapSig of tapScriptSig) {
+                const tapSigHash = allHashses.find((h) => tapSig.pubkey.equals(h.pubkey));
+                if (tapSigHash) {
+                    const isValidTapScriptSig = validator(tapSig.pubkey, tapSigHash.hash, trimTaprootSig(tapSig.signature));
+                    if (!isValidTapScriptSig)
+                        return false;
+                    validationResultCount++;
+                }
+            }
+        }
+        return validationResultCount > 0;
+    }
+    _signInput(inputIndex, keyPair, sighashTypes = [Transaction.SIGHASH_ALL]) {
+        hookSigner(keyPair);
+        const { hash, sighashType } = getHashAndSighashType(this.data.inputs, inputIndex, keyPair.publicKey, this.__CACHE, sighashTypes);
+        const partialSig = [
+            {
+                pubkey: keyPair.publicKey,
+                signature: bscript.signature.encode(keyPair.sign(hash), sighashType),
+            },
+        ];
+        this.data.updateInput(inputIndex, { partialSig });
+        return this;
+    }
+    _signTaprootInput(inputIndex, input, keyPair, tapLeafHashToSign, allowedSighashTypes = [Transaction.SIGHASH_DEFAULT]) {
+        hookSigner(keyPair);
+        const hashesForSig = this.checkTaprootHashesForSig(inputIndex, input, keyPair, tapLeafHashToSign, allowedSighashTypes);
+        const tapKeySig = hashesForSig
+            .filter((h) => !h.leafHash)
+            .map((h) => serializeTaprootSignature(keyPair.signSchnorr(h.hash), input.sighashType))[0];
+        const tapScriptSig = hashesForSig
+            .filter((h) => !!h.leafHash)
+            .map((h) => ({
+            pubkey: toXOnly(keyPair.publicKey),
+            signature: serializeTaprootSignature(keyPair.signSchnorr(h.hash), input.sighashType),
+            leafHash: h.leafHash,
+        }));
+        if (tapKeySig) {
+            this.data.updateInput(inputIndex, { tapKeySig });
+        }
+        if (tapScriptSig.length) {
+            this.data.updateInput(inputIndex, { tapScriptSig });
+        }
+        return this;
+    }
+    _signInputAsync(inputIndex, keyPair, sighashTypes = [Transaction.SIGHASH_ALL]) {
+        hookSigner(keyPair);
+        const { hash, sighashType } = getHashAndSighashType(this.data.inputs, inputIndex, keyPair.publicKey, this.__CACHE, sighashTypes);
+        return Promise.resolve(keyPair.sign(hash)).then((signature) => {
+            const partialSig = [
+                {
+                    pubkey: keyPair.publicKey,
+                    signature: bscript.signature.encode(signature, sighashType),
+                },
+            ];
+            this.data.updateInput(inputIndex, { partialSig });
+        });
+    }
+    async _signTaprootInputAsync(inputIndex, input, keyPair, tapLeafHash, sighashTypes = [Transaction.SIGHASH_DEFAULT]) {
+        hookSigner(keyPair);
+        const hashesForSig = this.checkTaprootHashesForSig(inputIndex, input, keyPair, tapLeafHash, sighashTypes);
+        const signaturePromises = [];
+        const tapKeyHash = hashesForSig.filter((h) => !h.leafHash)[0];
+        if (tapKeyHash) {
+            const tapKeySigPromise = Promise.resolve(keyPair.signSchnorr(tapKeyHash.hash)).then((sig) => {
+                return {
+                    tapKeySig: serializeTaprootSignature(sig, input.sighashType),
+                };
+            });
+            signaturePromises.push(tapKeySigPromise);
+        }
+        const tapScriptHashes = hashesForSig.filter((h) => !!h.leafHash);
+        if (tapScriptHashes.length) {
+            const tapScriptSigPromises = tapScriptHashes.map(async (tsh) => {
+                const signature = await keyPair.signSchnorr(tsh.hash);
+                const tapScriptSig = [
+                    {
+                        pubkey: toXOnly(keyPair.publicKey),
+                        signature: serializeTaprootSignature(signature, input.sighashType),
+                        leafHash: tsh.leafHash,
+                    },
+                ];
+                return { tapScriptSig };
+            });
+            signaturePromises.push(...tapScriptSigPromises);
+        }
+        const results = await Promise.all(signaturePromises);
+        for (const v of results) {
+            this.data.updateInput(inputIndex, v);
+        }
+    }
+}
+const transactionFromBuffer = (buffer) => new PsbtTransaction(buffer);
+class PsbtTransaction {
+    constructor(buffer = Buffer.from([2, 0, 0, 0, 0, 0, 0, 0, 0, 0])) {
+        this.tx = Transaction.fromBuffer(buffer);
+        checkTxEmpty(this.tx);
+        Object.defineProperty(this, 'tx', {
+            enumerable: false,
+            writable: true,
+        });
+    }
+    getInputOutputCounts() {
+        return {
+            inputCount: this.tx.ins.length,
+            outputCount: this.tx.outs.length,
+        };
+    }
+    addInput(input) {
+        if (input.hash === undefined ||
+            input.index === undefined ||
+            (!Buffer.isBuffer(input.hash) && typeof input.hash !== 'string') ||
+            typeof input.index !== 'number') {
+            throw new Error('Error adding input.');
+        }
+        const hash = typeof input.hash === 'string'
+            ? reverseBuffer(Buffer.from(input.hash, 'hex'))
+            : input.hash;
+        this.tx.addInput(hash, input.index, input.sequence);
+    }
+    addOutput(output) {
+        if (output.script === undefined ||
+            output.value === undefined ||
+            !Buffer.isBuffer(output.script) ||
+            typeof output.value !== 'number') {
+            throw new Error('Error adding output.');
+        }
+        this.tx.addOutput(output.script, output.value);
+    }
+    toBuffer() {
+        return this.tx.toBuffer();
+    }
+}
+function canFinalize(input, script, scriptType) {
+    switch (scriptType) {
+        case 'pubkey':
+        case 'pubkeyhash':
+        case 'witnesspubkeyhash':
+            return hasSigs(1, input.partialSig);
+        case 'multisig':
+            const p2ms = payments.p2ms({ output: script });
+            return hasSigs(p2ms.m, input.partialSig, p2ms.pubkeys);
+        default:
+            return false;
+    }
+}
+function checkCache(cache) {
+    if (cache.__UNSAFE_SIGN_NONSEGWIT !== false) {
+        throw new Error('Not BIP174 compliant, can not export');
+    }
+}
+function hasSigs(neededSigs, partialSig, pubkeys) {
+    if (!partialSig)
+        return false;
+    let sigs;
+    if (pubkeys) {
+        sigs = pubkeys
+            .map((pkey) => {
+            const pubkey = compressPubkey(pkey);
+            return partialSig.find((pSig) => pSig.pubkey.equals(pubkey));
+        })
+            .filter((v) => !!v);
+    }
+    else {
+        sigs = partialSig;
+    }
+    if (sigs.length > neededSigs)
+        throw new Error('Too many signatures');
+    return sigs.length === neededSigs;
+}
+function isFinalized(input) {
+    return !!input.finalScriptSig || !!input.finalScriptWitness;
+}
+function bip32DerivationIsMine(root) {
+    return (d) => {
+        if (!d.masterFingerprint.equals(root.fingerprint))
+            return false;
+        if (!root.derivePath(d.path).publicKey.equals(d.pubkey))
+            return false;
+        return true;
+    };
+}
+function check32Bit(num) {
+    if (typeof num !== 'number' || num !== Math.floor(num) || num > 0xffffffff || num < 0) {
+        throw new Error('Invalid 32 bit integer');
+    }
+}
+function checkFees(psbt, cache, opts) {
+    const feeRate = cache.__FEE_RATE || psbt.getFeeRate();
+    const vsize = cache.__EXTRACTED_TX.virtualSize();
+    const satoshis = feeRate * vsize;
+    if (feeRate >= opts.maximumFeeRate) {
+        throw new Error(`Warning: You are paying around ${(satoshis / 1e8).toFixed(8)} in ` +
+            `fees, which is ${feeRate} satoshi per byte for a transaction ` +
+            `with a VSize of ${vsize} bytes (segwit counted as 0.25 byte per ` +
+            `byte). Use setMaximumFeeRate method to raise your threshold, or ` +
+            `pass true to the first arg of extractTransaction.`);
+    }
+}
+function checkInputsForPartialSig(inputs, action) {
+    inputs.forEach((input) => {
+        const throws = isTaprootInput(input)
+            ? checkTaprootInputForSigs(input, action)
+            : checkInputForSig(input, action);
+        if (throws)
+            throw new Error('Can not modify transaction, signatures exist.');
+    });
+}
+function checkPartialSigSighashes(input) {
+    if (!input.sighashType || !input.partialSig)
+        return;
+    const { partialSig, sighashType } = input;
+    partialSig.forEach((pSig) => {
+        const { hashType } = bscript.signature.decode(pSig.signature);
+        if (sighashType !== hashType) {
+            throw new Error('Signature sighash does not match input sighash type');
+        }
+    });
+}
+function checkScriptForPubkey(pubkey, script, action) {
+    if (!pubkeyInScript(pubkey, script)) {
+        throw new Error(`Can not ${action} for this input with the key ${pubkey.toString('hex')}`);
+    }
+}
+function checkTxEmpty(tx) {
+    const isEmpty = tx.ins.every((input) => input.script &&
+        input.script.length === 0 &&
+        input.witness &&
+        input.witness.length === 0);
+    if (!isEmpty) {
+        throw new Error('Format Error: Transaction ScriptSigs are not empty');
+    }
+}
+function checkTxForDupeIns(tx, cache) {
+    tx.ins.forEach((input) => {
+        checkTxInputCache(cache, input);
+    });
+}
+function checkTxInputCache(cache, input) {
+    const key = reverseBuffer(Buffer.from(input.hash)).toString('hex') + ':' + input.index;
+    if (cache.__TX_IN_CACHE[key])
+        throw new Error('Duplicate input detected.');
+    cache.__TX_IN_CACHE[key] = 1;
+}
+function scriptCheckerFactory(payment, paymentScriptName) {
+    return (inputIndex, scriptPubKey, redeemScript, ioType) => {
+        const redeemScriptOutput = payment({
+            redeem: { output: redeemScript },
+        }).output;
+        if (!scriptPubKey.equals(redeemScriptOutput)) {
+            throw new Error(`${paymentScriptName} for ${ioType} #${inputIndex} doesn't match the scriptPubKey in the prevout`);
+        }
+    };
+}
+const checkRedeemScript = scriptCheckerFactory(payments.p2sh, 'Redeem script');
+const checkWitnessScript = scriptCheckerFactory(payments.p2wsh, 'Witness script');
+function getTxCacheValue(key, name, inputs, c, disableOutputChecks = false) {
+    if (!inputs.every(isFinalized))
+        throw new Error(`PSBT must be finalized to calculate ${name}`);
+    if (key === '__FEE_RATE' && c.__FEE_RATE)
+        return c.__FEE_RATE;
+    if (key === '__FEE' && c.__FEE)
+        return c.__FEE;
+    let tx;
+    let mustFinalize = true;
+    if (c.__EXTRACTED_TX) {
+        tx = c.__EXTRACTED_TX;
+        mustFinalize = false;
+    }
+    else {
+        tx = c.__TX.clone();
+    }
+    inputFinalizeGetAmts(inputs, tx, c, mustFinalize, disableOutputChecks);
+    if (key === '__FEE_RATE')
+        return c.__FEE_RATE;
+    else if (key === '__FEE')
+        return c.__FEE;
+}
+export function getFinalScripts(inputIndex, input, script, isSegwit, isP2SH, isP2WSH, canRunChecks = true) {
+    const scriptType = classifyScript(script);
+    if (!canFinalize(input, script, scriptType) && canRunChecks) {
+        throw new Error(`Can not finalize input #${inputIndex}`);
+    }
+    return prepareFinalScripts(script, scriptType, input.partialSig, isSegwit, isP2SH, isP2WSH);
+}
+export function prepareFinalScripts(script, scriptType, partialSig, isSegwit, isP2SH, isP2WSH) {
+    let finalScriptSig;
+    let finalScriptWitness;
+    const payment = getPayment(script, scriptType, partialSig);
+    const p2wsh = !isP2WSH ? null : payments.p2wsh({ redeem: payment });
+    const p2sh = !isP2SH ? null : payments.p2sh({ redeem: p2wsh || payment });
+    if (isSegwit) {
+        if (p2wsh) {
+            finalScriptWitness = witnessStackToScriptWitness(p2wsh.witness);
+        }
+        else {
+            finalScriptWitness = witnessStackToScriptWitness(payment.witness);
+        }
+        if (p2sh) {
+            finalScriptSig = p2sh.input;
+        }
+    }
+    else {
+        if (p2sh) {
+            finalScriptSig = p2sh.input;
+        }
+        else {
+            finalScriptSig = payment.input;
+        }
+    }
+    return {
+        finalScriptSig,
+        finalScriptWitness,
+    };
+}
+function getHashAndSighashType(inputs, inputIndex, pubkey, cache, sighashTypes) {
+    const input = checkForInput(inputs, inputIndex);
+    const { hash, sighashType, script } = getHashForSig(inputIndex, input, cache, false, sighashTypes);
+    checkScriptForPubkey(pubkey, script, 'sign');
+    return {
+        hash,
+        sighashType,
+    };
+}
+function getHashForSig(inputIndex, input, cache, forValidate, sighashTypes) {
+    const unsignedTx = cache.__TX;
+    const sighashType = input.sighashType || Transaction.SIGHASH_ALL;
+    checkSighashTypeAllowed(sighashType, sighashTypes);
+    let hash;
+    let prevout;
+    if (input.nonWitnessUtxo) {
+        const nonWitnessUtxoTx = nonWitnessUtxoTxFromCache(cache, input, inputIndex);
+        const prevoutHash = unsignedTx.ins[inputIndex].hash;
+        const utxoHash = nonWitnessUtxoTx.getHash();
+        if (!prevoutHash.equals(utxoHash)) {
+            throw new Error(`Non-witness UTXO hash for input #${inputIndex} doesn't match the hash specified in the prevout`);
+        }
+        const prevoutIndex = unsignedTx.ins[inputIndex].index;
+        prevout = nonWitnessUtxoTx.outs[prevoutIndex];
+    }
+    else if (input.witnessUtxo) {
+        prevout = input.witnessUtxo;
+    }
+    else {
+        throw new Error('Need a Utxo input item for signing');
+    }
+    const { meaningfulScript, type } = getMeaningfulScript(prevout.script, inputIndex, 'input', input.redeemScript, input.witnessScript);
+    if (['p2sh-p2wsh', 'p2wsh'].indexOf(type) >= 0) {
+        hash = unsignedTx.hashForWitnessV0(inputIndex, meaningfulScript, prevout.value, sighashType);
+    }
+    else if (isP2WPKH(meaningfulScript)) {
+        const signingScript = payments.p2pkh({
+            hash: meaningfulScript.slice(2),
+        }).output;
+        hash = unsignedTx.hashForWitnessV0(inputIndex, signingScript, prevout.value, sighashType);
+    }
+    else {
+        if (input.nonWitnessUtxo === undefined && cache.__UNSAFE_SIGN_NONSEGWIT === false)
+            throw new Error(`Input #${inputIndex} has witnessUtxo but non-segwit script: ` +
+                `${meaningfulScript.toString('hex')}`);
+        if (!forValidate && cache.__UNSAFE_SIGN_NONSEGWIT !== false)
+            console.warn('Warning: Signing non-segwit inputs without the full parent transaction ' +
+                'means there is a chance that a miner could feed you incorrect information ' +
+                "to trick you into paying large fees. This behavior is the same as Psbt's predecessor " +
+                '(TransactionBuilder - now removed) when signing non-segwit scripts. You are not ' +
+                'able to export this Psbt with toBuffer|toBase64|toHex since it is not ' +
+                'BIP174 compliant.\n*********************\nPROCEED WITH CAUTION!\n' +
+                '*********************');
+        hash = unsignedTx.hashForSignature(inputIndex, meaningfulScript, sighashType);
+    }
+    return {
+        script: meaningfulScript,
+        sighashType,
+        hash,
+    };
+}
+function getAllTaprootHashesForSig(inputIndex, input, inputs, cache) {
+    const allPublicKeys = [];
+    if (input.tapInternalKey) {
+        const key = getPrevoutTaprootKey(inputIndex, input, cache);
+        if (key) {
+            allPublicKeys.push(key);
+        }
+    }
+    if (input.tapScriptSig) {
+        const tapScriptPubkeys = input.tapScriptSig.map((tss) => tss.pubkey);
+        allPublicKeys.push(...tapScriptPubkeys);
+    }
+    const allHashes = allPublicKeys.map((pubicKey) => getTaprootHashesForSig(inputIndex, input, inputs, pubicKey, cache));
+    return allHashes.flat();
+}
+function getPrevoutTaprootKey(inputIndex, input, cache) {
+    const { script } = getScriptAndAmountFromUtxo(inputIndex, input, cache);
+    return isP2TR(script) ? script.subarray(2, 34) : null;
+}
+function trimTaprootSig(signature) {
+    return signature.length === 64 ? signature : signature.subarray(0, 64);
+}
+function getTaprootHashesForSig(inputIndex, input, inputs, pubkey, cache, tapLeafHashToSign, allowedSighashTypes) {
+    const unsignedTx = cache.__TX;
+    const sighashType = input.sighashType || Transaction.SIGHASH_DEFAULT;
+    checkSighashTypeAllowed(sighashType, allowedSighashTypes);
+    const prevOuts = inputs.map((i, index) => getScriptAndAmountFromUtxo(index, i, cache));
+    const signingScripts = prevOuts.map((o) => o.script);
+    const values = prevOuts.map((o) => o.value);
+    const hashes = [];
+    if (input.tapInternalKey && !tapLeafHashToSign) {
+        const outputKey = getPrevoutTaprootKey(inputIndex, input, cache) || Buffer.from([]);
+        if (toXOnly(pubkey).equals(outputKey)) {
+            const tapKeyHash = unsignedTx.hashForWitnessV1(inputIndex, signingScripts, values, sighashType);
+            hashes.push({ pubkey, hash: tapKeyHash });
+        }
+    }
+    const tapLeafHashes = (input.tapLeafScript || [])
+        .filter((tapLeaf) => pubkeyInScript(pubkey, tapLeaf.script))
+        .map((tapLeaf) => {
+        const hash = tapleafHash({
+            output: tapLeaf.script,
+            version: tapLeaf.leafVersion,
+        });
+        return Object.assign({ hash }, tapLeaf);
+    })
+        .filter((tapLeaf) => !tapLeafHashToSign || tapLeafHashToSign.equals(tapLeaf.hash))
+        .map((tapLeaf) => {
+        const tapScriptHash = unsignedTx.hashForWitnessV1(inputIndex, signingScripts, values, sighashType, tapLeaf.hash);
+        return {
+            pubkey,
+            hash: tapScriptHash,
+            leafHash: tapLeaf.hash,
+        };
+    });
+    return hashes.concat(tapLeafHashes);
+}
+function checkSighashTypeAllowed(sighashType, sighashTypes) {
+    if (sighashTypes && sighashTypes.indexOf(sighashType) < 0) {
+        const str = sighashTypeToString(sighashType);
+        throw new Error(`Sighash type is not allowed. Retry the sign method passing the ` +
+            `sighashTypes array of whitelisted types. Sighash type: ${str}`);
+    }
+}
+function getPayment(script, scriptType, partialSig) {
+    let payment;
+    switch (scriptType) {
+        case 'multisig':
+            const sigs = getSortedSigs(script, partialSig);
+            payment = payments.p2ms({
+                output: script,
+                signatures: sigs,
+            });
+            break;
+        case 'pubkey':
+            payment = payments.p2pk({
+                output: script,
+                signature: partialSig[0].signature,
+            });
+            break;
+        case 'pubkeyhash':
+            payment = payments.p2pkh({
+                output: script,
+                pubkey: partialSig[0].pubkey,
+                signature: partialSig[0].signature,
+            });
+            break;
+        case 'witnesspubkeyhash':
+            payment = payments.p2wpkh({
+                output: script,
+                pubkey: partialSig[0].pubkey,
+                signature: partialSig[0].signature,
+            });
+            break;
+    }
+    return payment;
+}
+function getScriptFromInput(inputIndex, input, cache) {
+    const unsignedTx = cache.__TX;
+    const res = {
+        script: null,
+        isSegwit: false,
+        isP2SH: false,
+        isP2WSH: false,
+    };
+    res.isP2SH = !!input.redeemScript;
+    res.isP2WSH = !!input.witnessScript;
+    if (input.witnessScript) {
+        res.script = input.witnessScript;
+    }
+    else if (input.redeemScript) {
+        res.script = input.redeemScript;
+    }
+    else {
+        if (input.nonWitnessUtxo) {
+            const nonWitnessUtxoTx = nonWitnessUtxoTxFromCache(cache, input, inputIndex);
+            const prevoutIndex = unsignedTx.ins[inputIndex].index;
+            res.script = nonWitnessUtxoTx.outs[prevoutIndex].script;
+        }
+        else if (input.witnessUtxo) {
+            res.script = input.witnessUtxo.script;
+        }
+    }
+    if (input.witnessScript || isP2WPKH(res.script)) {
+        res.isSegwit = true;
+    }
+    return res;
+}
+function getSignersFromHD(inputIndex, inputs, hdKeyPair) {
+    const input = checkForInput(inputs, inputIndex);
+    if (!input.bip32Derivation || input.bip32Derivation.length === 0) {
+        throw new Error('Need bip32Derivation to sign with HD');
+    }
+    const myDerivations = input.bip32Derivation
+        .map((bipDv) => {
+        if (bipDv.masterFingerprint.equals(hdKeyPair.fingerprint)) {
+            return bipDv;
+        }
+        else {
+            return;
+        }
+    })
+        .filter((v) => !!v);
+    if (myDerivations.length === 0) {
+        throw new Error('Need one bip32Derivation masterFingerprint to match the HDSigner fingerprint');
+    }
+    return myDerivations.map((bipDv) => {
+        const node = hdKeyPair.derivePath(bipDv.path);
+        if (!bipDv.pubkey.equals(node.publicKey)) {
+            throw new Error('pubkey did not match bip32Derivation');
+        }
+        return node;
+    });
+}
+function getSortedSigs(script, partialSig) {
+    const p2ms = payments.p2ms({ output: script });
+    return p2ms
+        .pubkeys.map((pk) => {
+        return (partialSig.filter((ps) => {
+            return ps.pubkey.equals(pk);
+        })[0] || {}).signature;
+    })
+        .filter((v) => !!v);
+}
+function scriptWitnessToWitnessStack(buffer) {
+    let offset = 0;
+    function readSlice(n) {
+        offset += n;
+        return buffer.slice(offset - n, offset);
+    }
+    function readVarInt() {
+        const vi = varuint.decode(buffer, offset);
+        offset += varuint.decode.bytes;
+        return vi;
+    }
+    function readVarSlice() {
+        return readSlice(readVarInt());
+    }
+    function readVector() {
+        const count = readVarInt();
+        const vector = [];
+        for (let i = 0; i < count; i++)
+            vector.push(readVarSlice());
+        return vector;
+    }
+    return readVector();
+}
+function sighashTypeToString(sighashType) {
+    let text = sighashType & Transaction.SIGHASH_ANYONECANPAY ? 'SIGHASH_ANYONECANPAY | ' : '';
+    const sigMod = sighashType & 0x1f;
+    switch (sigMod) {
+        case Transaction.SIGHASH_ALL:
+            text += 'SIGHASH_ALL';
+            break;
+        case Transaction.SIGHASH_SINGLE:
+            text += 'SIGHASH_SINGLE';
+            break;
+        case Transaction.SIGHASH_NONE:
+            text += 'SIGHASH_NONE';
+            break;
+    }
+    return text;
+}
+function addNonWitnessTxCache(cache, input, inputIndex) {
+    cache.__NON_WITNESS_UTXO_BUF_CACHE[inputIndex] = input.nonWitnessUtxo;
+    cache.__NON_WITNESS_UTXO_TX_CACHE[inputIndex] = Transaction.fromBuffer(input.nonWitnessUtxo);
+    const self = cache;
+    const selfIndex = inputIndex;
+    delete input.nonWitnessUtxo;
+    Object.defineProperty(input, 'nonWitnessUtxo', {
+        enumerable: true,
+        get() {
+            const buf = self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex];
+            const txCache = self.__NON_WITNESS_UTXO_TX_CACHE[selfIndex];
+            if (buf !== undefined) {
+                return buf;
+            }
+            else {
+                const newBuf = txCache.toBuffer();
+                self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex] = newBuf;
+                return newBuf;
+            }
+        },
+        set(data) {
+            self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex] = data;
+        },
+    });
+}
+function inputFinalizeGetAmts(inputs, tx, cache, mustFinalize, disableOutputChecks) {
+    let inputAmount = 0;
+    inputs.forEach((input, idx) => {
+        if (mustFinalize && input.finalScriptSig)
+            tx.ins[idx].script = input.finalScriptSig;
+        if (mustFinalize && input.finalScriptWitness) {
+            tx.ins[idx].witness = scriptWitnessToWitnessStack(input.finalScriptWitness);
+        }
+        if (input.witnessUtxo) {
+            inputAmount += input.witnessUtxo.value;
+        }
+        else if (input.nonWitnessUtxo) {
+            const nwTx = nonWitnessUtxoTxFromCache(cache, input, idx);
+            const vout = tx.ins[idx].index;
+            const out = nwTx.outs[vout];
+            inputAmount += out.value;
+        }
+    });
+    const outputAmount = tx.outs.reduce((total, o) => total + o.value, 0);
+    const fee = inputAmount - outputAmount;
+    if (!disableOutputChecks) {
+        if (fee < 0) {
+            throw new Error('Outputs are spending more than Inputs');
+        }
+    }
+    const bytes = tx.virtualSize();
+    cache.__FEE = fee;
+    cache.__EXTRACTED_TX = tx;
+    cache.__FEE_RATE = Math.floor(fee / bytes);
+}
+function nonWitnessUtxoTxFromCache(cache, input, inputIndex) {
+    const c = cache.__NON_WITNESS_UTXO_TX_CACHE;
+    if (!c[inputIndex]) {
+        addNonWitnessTxCache(cache, input, inputIndex);
+    }
+    return c[inputIndex];
+}
+function getScriptFromUtxo(inputIndex, input, cache) {
+    const { script } = getScriptAndAmountFromUtxo(inputIndex, input, cache);
+    return script;
+}
+function getScriptAndAmountFromUtxo(inputIndex, input, cache) {
+    if (input.witnessUtxo !== undefined) {
+        return {
+            script: input.witnessUtxo.script,
+            value: input.witnessUtxo.value,
+        };
+    }
+    else if (input.nonWitnessUtxo !== undefined) {
+        const nonWitnessUtxoTx = nonWitnessUtxoTxFromCache(cache, input, inputIndex);
+        const o = nonWitnessUtxoTx.outs[cache.__TX.ins[inputIndex].index];
+        return { script: o.script, value: o.value };
+    }
+    else {
+        throw new Error("Can't find pubkey in input without Utxo data");
+    }
+}
+function pubkeyInInput(pubkey, input, inputIndex, cache) {
+    const script = getScriptFromUtxo(inputIndex, input, cache);
+    const { meaningfulScript } = getMeaningfulScript(script, inputIndex, 'input', input.redeemScript, input.witnessScript);
+    return pubkeyInScript(pubkey, meaningfulScript);
+}
+function pubkeyInOutput(pubkey, output, outputIndex, cache) {
+    const script = cache.__TX.outs[outputIndex].script;
+    const { meaningfulScript } = getMeaningfulScript(script, outputIndex, 'output', output.redeemScript, output.witnessScript);
+    return pubkeyInScript(pubkey, meaningfulScript);
+}
+function redeemFromFinalScriptSig(finalScript) {
+    if (!finalScript)
+        return;
+    const decomp = bscript.decompile(finalScript);
+    if (!decomp)
+        return;
+    const lastItem = decomp[decomp.length - 1];
+    if (!Buffer.isBuffer(lastItem) || isPubkeyLike(lastItem) || isSigLike(lastItem))
+        return;
+    const sDecomp = bscript.decompile(lastItem);
+    if (!sDecomp)
+        return;
+    return lastItem;
+}
+function redeemFromFinalWitnessScript(finalScript) {
+    if (!finalScript)
+        return;
+    const decomp = scriptWitnessToWitnessStack(finalScript);
+    const lastItem = decomp[decomp.length - 1];
+    if (isPubkeyLike(lastItem))
+        return;
+    const sDecomp = bscript.decompile(lastItem);
+    if (!sDecomp)
+        return;
+    return lastItem;
+}
+function compressPubkey(pubkey) {
+    if (pubkey.length === 65) {
+        const parity = pubkey[64] & 1;
+        const newKey = pubkey.slice(0, 33);
+        newKey[0] = 2 | parity;
+        return newKey;
+    }
+    return pubkey.slice();
+}
+function isPubkeyLike(buf) {
+    return buf.length === 33 && bscript.isCanonicalPubKey(buf);
+}
+function isSigLike(buf) {
+    return bscript.isCanonicalScriptSignature(buf);
+}
+function getMeaningfulScript(script, index, ioType, redeemScript, witnessScript) {
+    const isP2SH = isP2SHScript(script);
+    const isP2SHP2WSH = isP2SH && redeemScript && isP2WSHScript(redeemScript);
+    const isP2WSH = isP2WSHScript(script);
+    if (isP2SH && redeemScript === undefined)
+        throw new Error('scriptPubkey is P2SH but redeemScript missing');
+    if ((isP2WSH || isP2SHP2WSH) && witnessScript === undefined)
+        throw new Error('scriptPubkey or redeemScript is P2WSH but witnessScript missing');
+    let meaningfulScript;
+    if (isP2SHP2WSH) {
+        meaningfulScript = witnessScript;
+        checkRedeemScript(index, script, redeemScript, ioType);
+        checkWitnessScript(index, redeemScript, witnessScript, ioType);
+        checkInvalidP2WSH(meaningfulScript);
+    }
+    else if (isP2WSH) {
+        meaningfulScript = witnessScript;
+        checkWitnessScript(index, script, witnessScript, ioType);
+        checkInvalidP2WSH(meaningfulScript);
+    }
+    else if (isP2SH) {
+        meaningfulScript = redeemScript;
+        checkRedeemScript(index, script, redeemScript, ioType);
+    }
+    else {
+        meaningfulScript = script;
+    }
+    return {
+        meaningfulScript,
+        type: isP2SHP2WSH ? 'p2sh-p2wsh' : isP2SH ? 'p2sh' : isP2WSH ? 'p2wsh' : 'raw',
+    };
+}
+function checkInvalidP2WSH(script) {
+    if (isP2WPKH(script) || isP2SHScript(script)) {
+        throw new Error('P2WPKH or P2SH can not be contained within P2WSH');
+    }
+}
+function classifyScript(script) {
+    if (isP2WPKH(script))
+        return 'witnesspubkeyhash';
+    if (isP2PKH(script))
+        return 'pubkeyhash';
+    if (isP2MS(script))
+        return 'multisig';
+    if (isP2PK(script))
+        return 'pubkey';
+    return 'nonstandard';
+}
+function range(n) {
+    return [...Array(n).keys()];
+}