@btc-vision/bitcoin 7.0.0-alpha.0 → 7.0.0-alpha.10

package/build/psbt.js

@@ -1,32 +1,44 @@
-import { Psbt as PsbtBase, checkForInput, checkForOutput, } from 'bip174';
-import { clone, reverse, equals, fromHex, toHex, fromBase64 } from './io/index.js';
-import { fromOutputScript, isUnknownSegwitVersion, toOutputScript } from './address.js';
+import { checkForInput, checkForOutput, Psbt as PsbtBase } from 'bip174';
+import { clone, equals, fromBase64, fromHex, toHex } from './io/index.js';
+import { fromOutputScript, toOutputScript } from './address.js';
 import { bitcoin as btcNetwork } from './networks.js';
 import * as payments from './payments/index.js';
-import { tapleafHash } from './payments/bip341.js';
 import { checkTaprootInputFields, checkTaprootOutputFields, isTaprootInput, serializeTaprootSignature, tapScriptFinalizer, } from './psbt/bip371.js';
 import { toXOnly } from './pubkey.js';
-import { isP2TR, isP2WPKH, pubkeyInScript, witnessStackToScriptWitness, } from './psbt/psbtutils.js';
-import { check32Bit, checkCache, checkInputsForPartialSig, checkPartialSigSighashes, checkScriptForPubkey, checkTxEmpty, checkTxForDupeIns, checkTxInputCache, isFinalized, } from './psbt/validation.js';
-import { checkInvalidP2WSH, classifyScript, compressPubkey, getMeaningfulScript, isPubkeyLike, isSigLike, range, scriptWitnessToWitnessStack, sighashTypeToString, } from './psbt/utils.js';
 import * as bscript from './script.js';
 import { Transaction } from './transaction.js';
+// Import composition classes
+import { PsbtCache } from './psbt/PsbtCache.js';
+import { PsbtSigner } from './psbt/PsbtSigner.js';
+import { getFinalScripts as _getFinalScripts, prepareFinalScripts as _prepareFinalScripts, PsbtFinalizer, } from './psbt/PsbtFinalizer.js';
+import { PsbtTransaction, transactionFromBuffer } from './psbt/PsbtTransaction.js';
+import { check32Bit, checkCache, checkInputsForPartialSig, checkPartialSigSighashes, checkScriptForPubkey, checkTxForDupeIns, checkTxInputCache, isFinalized, } from './psbt/validation.js';
+import { checkInvalidP2WSH, classifyScript, getMeaningfulScript, range } from './psbt/utils.js';
+import { witnessStackToScriptWitness } from './psbt/psbtutils.js';
+// Re-export for backwards compatibility
+export { getFinalScripts, prepareFinalScripts };
+export { PsbtCache } from './psbt/PsbtCache.js';
+export { PsbtSigner } from './psbt/PsbtSigner.js';
+export { PsbtFinalizer } from './psbt/PsbtFinalizer.js';
+export { PsbtTransaction, transactionFromBuffer } from './psbt/PsbtTransaction.js';
 /**
  * These are the default arguments for a Psbt instance.
  */
 const DEFAULT_OPTS = {
-    /**
-     * A bitcoinjs Network object. This is only used if you pass an `address`
-     * parameter to addOutput. Otherwise it is not needed and can be left default.
-     */
     network: btcNetwork,
-    /**
-     * When extractTransaction is called, the fee rate is checked.
-     * THIS IS NOT TO BE RELIED ON.
-     * It is only here as a last ditch effort to prevent sending a 500 BTC fee etc.
-     */
-    maximumFeeRate: 5000, // satoshi per byte
+    maximumFeeRate: 5000,
 };
+/** Helper to create a Transaction from a buffer */
+function txFromBuffer(buf) {
+    return Transaction.fromBuffer(buf);
+}
+// Standalone exports that delegate to PsbtFinalizer
+function getFinalScripts(inputIndex, input, script, isSegwit, isP2SH, isP2WSH, canRunChecks = true, solution) {
+    return _getFinalScripts(inputIndex, input, script, isSegwit, isP2SH, isP2WSH, canRunChecks, solution);
+}
+function prepareFinalScripts(script, scriptType, partialSig, isSegwit, isP2SH, isP2WSH, solution) {
+    return _prepareFinalScripts(script, scriptType, partialSig, isSegwit, isP2SH, isP2WSH, solution);
+}
 /**
  * Psbt class can parse and generate a PSBT binary based off of the BIP174.
  * There are 6 roles that this class fulfills. (Explained in BIP174)
@@ -64,39 +76,23 @@ const DEFAULT_OPTS = {
  * Transaction Extractor: This role will perform some checks before returning a
  *   Transaction object. Such as fee rate not being larger than maximumFeeRate etc.
  */
-/**
- * Psbt class can parse and generate a PSBT binary based off of the BIP174.
- */
 export class Psbt {
     data;
     #cache;
+    #signer;
+    #finalizer;
     #opts;
     constructor(opts = {}, data = new PsbtBase(new PsbtTransaction())) {
         this.data = data;
         this.#opts = Object.assign({}, DEFAULT_OPTS, opts);
-        this.#cache = {
-            nonWitnessUtxoTxCache: [],
-            nonWitnessUtxoBufCache: [],
-            txInCache: {},
-            // unsignedTx.tx property is dynamically added by PsbtBase
-            tx: this.data.globalMap.unsignedTx.tx,
-            unsafeSignNonSegwit: false,
-            hasSignatures: false,
-        };
+        const tx = this.data.globalMap.unsignedTx.tx;
+        this.#cache = new PsbtCache(tx);
         if (opts.version === 3) {
             this.setVersionTRUC();
         }
         else if (this.data.inputs.length === 0)
             this.setVersion(2);
     }
-    /** @internal - Exposed for testing. Do not use in production code. */
-    get __CACHE() {
-        return this.#cache;
-    }
-    /** @internal - Exposed for testing. Do not use in production code. */
-    get opts() {
-        return this.#opts;
-    }
     get inputCount() {
         return this.data.inputs.length;
     }
@@ -125,7 +121,9 @@ export class Psbt {
             try {
                 address = fromOutputScript(output.script, this.#opts.network);
             }
-            catch (_) { }
+            catch (_) {
+                // Not all scripts can be converted to an address
+            }
             return {
                 script: clone(output.script),
                 value: output.value,
@@ -133,6 +131,20 @@ export class Psbt {
             };
         });
     }
+    /** Lazily initialized signer - created on first access */
+    get #lazySigner() {
+        if (!this.#signer) {
+            this.#signer = new PsbtSigner(this.#cache, txFromBuffer);
+        }
+        return this.#signer;
+    }
+    /** Lazily initialized finalizer - created on first access */
+    get #lazyFinalizer() {
+        if (!this.#finalizer) {
+            this.#finalizer = new PsbtFinalizer(this.#cache, txFromBuffer);
+        }
+        return this.#finalizer;
+    }
     static fromBase64(data, opts = {}) {
         const buffer = fromBase64(data);
         return this.fromBuffer(buffer, opts);
@@ -145,7 +157,6 @@ export class Psbt {
         const psbtBase = PsbtBase.fromBuffer(buffer, transactionFromBuffer);
         const psbt = new Psbt(opts, psbtBase);
         checkTxForDupeIns(psbt.#cache.tx, psbt.#cache);
-        // Check if restored PSBT has any signatures (partial or finalized)
         psbt.#cache.hasSignatures = psbt.data.inputs.some((input) => input.partialSig?.length ||
             input.tapKeySig ||
             input.tapScriptSig?.length ||
@@ -158,20 +169,21 @@ export class Psbt {
         return this;
     }
     clone() {
-        // TODO: more efficient cloning
-        const clonedOpts = JSON.parse(JSON.stringify(this.#opts));
+        const clonedOpts = structuredClone(this.#opts);
         return Psbt.fromBuffer(new Uint8Array(this.data.toBuffer()), clonedOpts);
     }
+    get maximumFeeRate() {
+        return this.#opts.maximumFeeRate;
+    }
     setMaximumFeeRate(satoshiPerByte) {
-        check32Bit(satoshiPerByte); // 42.9 BTC per byte IS excessive... so throw
+        check32Bit(satoshiPerByte);
         this.#opts.maximumFeeRate = satoshiPerByte;
     }
     setVersion(version) {
         check32Bit(version);
         checkInputsForPartialSig(this.data.inputs, 'setVersion', this.#cache.hasSignatures);
-        const c = this.#cache;
-        c.tx.version = version;
-        c.extractedTx = undefined;
+        this.#cache.tx.version = version;
+        this.#cache.invalidate('outputs');
         return this;
     }
     setVersionTRUC() {
@@ -180,20 +192,18 @@ export class Psbt {
     setLocktime(locktime) {
         check32Bit(locktime);
         checkInputsForPartialSig(this.data.inputs, 'setLocktime', this.#cache.hasSignatures);
-        const c = this.#cache;
-        c.tx.locktime = locktime;
-        c.extractedTx = undefined;
+        this.#cache.tx.locktime = locktime;
+        this.#cache.invalidate('outputs');
         return this;
     }
     setInputSequence(inputIndex, sequence) {
         check32Bit(sequence);
         checkInputsForPartialSig(this.data.inputs, 'setInputSequence', this.#cache.hasSignatures);
-        const c = this.#cache;
-        if (c.tx.ins.length <= inputIndex) {
+        if (this.#cache.tx.ins.length <= inputIndex) {
             throw new Error('Input index too high');
         }
-        c.tx.ins[inputIndex].sequence = sequence;
-        c.extractedTx = undefined;
+        this.#cache.tx.ins[inputIndex].sequence = sequence;
+        this.#cache.invalidate('outputs');
         return this;
     }
     addInputs(inputDatas, checkPartialSigs = true) {
@@ -211,7 +221,6 @@ export class Psbt {
         }
         if (inputData.witnessScript)
             checkInvalidP2WSH(inputData.witnessScript);
-        // Convert witnessUtxo for bip174 v3 compatibility (value: bigint, script: Uint8Array)
         const normalizedInputData = inputData.witnessUtxo
             ? {
                 ...inputData,
@@ -223,45 +232,25 @@ export class Psbt {
                 },
             }
             : inputData;
-        const c = this.#cache;
         this.data.addInput(normalizedInputData);
-        const txIn = c.tx.ins[c.tx.ins.length - 1];
-        checkTxInputCache(c, txIn);
+        const txIn = this.#cache.tx.ins[this.#cache.tx.ins.length - 1];
+        checkTxInputCache(this.#cache, txIn);
         const inputIndex = this.data.inputs.length - 1;
         const input = this.data.inputs[inputIndex];
         if (input.nonWitnessUtxo) {
-            addNonWitnessTxCache(this.#cache, input, inputIndex);
+            this.#cache.addNonWitnessTxCache(input, inputIndex, txFromBuffer);
         }
-        c.fee = undefined;
-        c.feeRate = undefined;
-        c.extractedTx = undefined;
-        c.prevOuts = undefined;
-        c.signingScripts = undefined;
-        c.values = undefined;
-        c.taprootHashCache = undefined;
+        this.#cache.invalidate('full');
         return this;
     }
     addOutputs(outputDatas, checkPartialSigs = true) {
         outputDatas.forEach((outputData) => this.addOutput(outputData, checkPartialSigs));
         return this;
     }
-    /**
-     * Add an output to the PSBT.
-     *
-     * **PERFORMANCE WARNING:** Passing an `address` string is ~10x slower than passing
-     * a `script` directly due to address parsing overhead (bech32 decode, etc.).
-     * For high-performance use cases with many outputs, pre-compute the script using
-     * `toOutputScript(address, network)` and pass `{ script, value }` instead.
-     *
-     * @param outputData - Output data with either `address` or `script`, and `value`
-     * @param checkPartialSigs - Whether to check for existing signatures (default: true)
-     */
     addOutput(outputData, checkPartialSigs = true) {
         const hasAddress = 'address' in outputData;
         const hasScript = 'script' in outputData;
-        if (!outputData ||
-            outputData.value === undefined ||
-            (!hasAddress && !hasScript)) {
+        if (!outputData || outputData.value === undefined || (!hasAddress && !hasScript)) {
             throw new Error(`Invalid arguments for Psbt.addOutput. ` +
                 `Requires single object with at least [script or address] and [value]`);
         }
@@ -275,12 +264,8 @@ export class Psbt {
             outputData = Object.assign({}, outputData, { script });
         }
         checkTaprootOutputFields(outputData, outputData, 'addOutput');
-        const c = this.#cache;
         this.data.addOutput(outputData);
-        c.fee = undefined;
-        c.feeRate = undefined;
-        c.extractedTx = undefined;
-        c.taprootHashCache = undefined;
+        this.#cache.invalidate('outputs');
         return this;
     }
     extractTransaction(disableFeeCheck, disableOutputChecks) {
@@ -289,24 +274,24 @@ export class Psbt {
         }
         if (!this.data.inputs.every(isFinalized))
             throw new Error('Not finalized');
-        const c = this.#cache;
         if (!disableFeeCheck) {
-            checkFees(this, c, this.#opts);
+            this.#cache.computeFeeRate(this.data.inputs, disableOutputChecks, txFromBuffer);
+            this.#cache.checkFees(this.#opts);
         }
-        if (c.extractedTx)
-            return c.extractedTx;
-        const tx = c.tx.clone();
-        inputFinalizeGetAmts(this.data.inputs, tx, c, true, disableOutputChecks);
+        if (this.#cache.extractedTx)
+            return this.#cache.extractedTx;
+        const tx = this.#cache.tx.clone();
+        this.#cache.finalizeAndComputeAmounts(this.data.inputs, tx, true, disableOutputChecks, txFromBuffer);
         return tx;
     }
     getFeeRate(disableOutputChecks = false) {
-        return getTxCacheValue('feeRate', 'fee rate', this.data.inputs, this.#cache, disableOutputChecks);
+        return this.#cache.computeFeeRate(this.data.inputs, disableOutputChecks, txFromBuffer);
     }
     getFee(disableOutputChecks = false) {
-        return getTxCacheValue('fee', 'fee', this.data.inputs, this.#cache, disableOutputChecks);
+        return this.#cache.computeFee(this.data.inputs, disableOutputChecks, txFromBuffer);
     }
     finalizeAllInputs() {
-        checkForInput(this.data.inputs, 0); // making sure we have at least one
+        checkForInput(this.data.inputs, 0);
         range(this.data.inputs.length).forEach((idx) => this.finalizeInput(idx));
         return this;
     }
@@ -325,36 +310,35 @@ export class Psbt {
     }
     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 script = this.#cache.getScriptFromUtxo(inputIndex, input, txFromBuffer);
+        const result = getMeaningfulScript(script, inputIndex, 'input', input.redeemScript || this.#cache.redeemFromFinalScriptSig(input.finalScriptSig), input.witnessScript ||
+            this.#cache.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);
+        return this.#cache.pubkeyInInput(pubkey, input, inputIndex, txFromBuffer);
     }
     inputHasHDKey(inputIndex, root) {
         const input = checkForInput(this.data.inputs, inputIndex);
-        const derivationIsMine = bip32DerivationIsMine(root);
+        const derivationIsMine = this.#lazySigner.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);
+        return this.#cache.pubkeyInOutput(pubkey, output, outputIndex);
     }
     outputHasHDKey(outputIndex, root) {
         const output = checkForOutput(this.data.outputs, outputIndex);
-        const derivationIsMine = bip32DerivationIsMine(root);
+        const derivationIsMine = this.#lazySigner.bip32DerivationIsMine(root);
         return !!output.bip32Derivation && output.bip32Derivation.some(derivationIsMine);
     }
     validateSignaturesOfAllInputs(validator) {
-        checkForInput(this.data.inputs, 0); // making sure we have at least one
+        checkForInput(this.data.inputs, 0);
         const results = range(this.data.inputs.length).map((idx) => this.validateSignaturesOfInput(idx, validator));
-        return results.reduce((final, res) => res && final, true);
+        return results.every((res) => res);
     }
     validateSignaturesOfInput(inputIndex, validator, pubkey) {
         const input = this.data.inputs[inputIndex];
@@ -381,56 +365,43 @@ export class Psbt {
         }
         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)) {
-                    return reject(new Error('No inputs were signed'));
-                }
-                resolve();
-            });
-        });
+    async signAllInputsHDAsync(hdKeyPair, sighashTypes = [Transaction.SIGHASH_ALL]) {
+        if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
+            throw 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);
+            }));
+        }
+        await Promise.all(promises);
+        if (results.every((v) => !v)) {
+            throw new Error('No inputs were signed');
+        }
     }
     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);
+        const signers = this.#lazySigner.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);
-        });
+    async signInputHDAsync(inputIndex, hdKeyPair, sighashTypes = [Transaction.SIGHASH_ALL]) {
+        if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
+            throw new Error('Need HDSigner to sign input');
+        }
+        const signers = this.#lazySigner.getSignersFromHD(inputIndex, this.data.inputs, hdKeyPair);
+        const promises = signers.map((signer) => this.signInputAsync(inputIndex, signer, sighashTypes));
+        await Promise.all(promises);
     }
     signAllInputs(keyPair, sighashTypes) {
         if (!keyPair || !keyPair.publicKey)
             throw new Error('Need Signer to sign input');
-        // TODO: Add a pubkey/pubkeyhash cache to each input
-        // as input information is added, then eventually
-        // optimize this method.
         const results = [];
         for (const i of range(this.data.inputs.length)) {
             try {
@@ -446,29 +417,22 @@ export class Psbt {
         }
         return this;
     }
-    signAllInputsAsync(keyPair, sighashTypes) {
-        return new Promise((resolve, reject) => {
-            if (!keyPair || !keyPair.publicKey)
-                return reject(new Error('Need Signer to sign input'));
-            // TODO: Add a pubkey/pubkeyhash cache to each input
-            // as input information is added, then eventually
-            // optimize this method.
-            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)) {
-                    return reject(new Error('No inputs were signed'));
-                }
-                resolve();
-            });
-        });
+    async signAllInputsAsync(keyPair, sighashTypes) {
+        if (!keyPair || !keyPair.publicKey)
+            throw 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);
+            }));
+        }
+        await Promise.all(promises);
+        if (results.every((v) => !v)) {
+            throw new Error('No inputs were signed');
+        }
     }
     signInput(inputIndex, keyPair, sighashTypes) {
         if (!keyPair || !keyPair.publicKey) {
@@ -490,25 +454,21 @@ export class Psbt {
         }
         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);
-        });
+    async signInputAsync(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.#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.`);
-        });
+    async signTaprootInputAsync(inputIndex, keyPair, tapLeafHash, 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.#signTaprootInputAsync(inputIndex, input, keyPair, tapLeafHash, sighashTypes);
+        throw new Error(`Input #${inputIndex} is not of type Taproot.`);
     }
     toBuffer() {
         checkCache(this.#cache);
@@ -530,7 +490,6 @@ export class Psbt {
         if (updateData.witnessScript)
             checkInvalidP2WSH(updateData.witnessScript);
         checkTaprootInputFields(this.data.inputs[inputIndex], updateData, 'updateInput');
-        // Convert witnessUtxo for bip174 v3 compatibility (value: bigint, script: Uint8Array)
         const normalizedUpdate = updateData.witnessUtxo
             ? {
                 ...updateData,
@@ -544,7 +503,7 @@ export class Psbt {
             : updateData;
         this.data.updateInput(inputIndex, normalizedUpdate);
         if (updateData.nonWitnessUtxo) {
-            addNonWitnessTxCache(this.#cache, this.data.inputs[inputIndex], inputIndex);
+            this.#cache.addNonWitnessTxCache(this.data.inputs[inputIndex], inputIndex, txFromBuffer);
         }
         return this;
     }
@@ -576,13 +535,13 @@ export class Psbt {
         const pubkey = keyPair.publicKey instanceof Uint8Array
             ? keyPair.publicKey
             : new Uint8Array(keyPair.publicKey);
-        const hashesForSig = getTaprootHashesForSig(inputIndex, input, this.data.inputs, pubkey, this.#cache, tapLeafHashToSign, allowedSighashTypes);
+        const hashesForSig = this.#lazySigner.getTaprootHashesForSig(inputIndex, input, this.data.inputs, pubkey, tapLeafHashToSign, allowedSighashTypes);
         if (!hashesForSig || !hashesForSig.length)
             throw new Error(`Can not sign for input #${inputIndex} with the key ${toHex(pubkey)}`);
         return hashesForSig;
     }
     #finalizeInput(inputIndex, input, finalScriptsFunc = getFinalScripts, canRunChecks = true) {
-        const { script, isP2SH, isP2WSH, isSegwit } = getScriptFromInput(inputIndex, input, this.#cache);
+        const { script, isP2SH, isP2WSH, isSegwit } = this.#lazyFinalizer.getScriptFromInput(inputIndex, input);
         if (!script)
             throw new Error(`No script found for input #${inputIndex}`);
         checkPartialSigSighashes(input);
@@ -599,7 +558,6 @@ export class Psbt {
     #finalizeTaprootInput(inputIndex, input, tapLeafHashToFinalize, finalScriptsFunc = tapScriptFinalizer) {
         if (!input.witnessUtxo)
             throw new Error(`Cannot finalize input #${inputIndex}. Missing witness utxo.`);
-        // Check key spend first. Increased privacy and reduced block space.
         if (input.tapKeySig) {
             const payment = payments.p2tr({
                 output: input.witnessUtxo.script,
@@ -619,14 +577,12 @@ export class Psbt {
     }
     #validateSignaturesOfInput(inputIndex, validator, pubkey) {
         const input = this.data.inputs[inputIndex];
-        const partialSig = (input || {}).partialSig;
+        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) => equals(sig.pubkey, pubkey))
-            : partialSig;
+        const mySigs = pubkey ? partialSig.filter((sig) => equals(sig.pubkey, pubkey)) : partialSig;
         if (mySigs.length < 1)
             throw new Error('No signatures for this pubkey');
         const results = [];
@@ -638,9 +594,9 @@ export class Psbt {
             const pSigPubkey = pSig.pubkey;
             const sig = bscript.signature.decode(pSigSignature);
             const { hash, script } = sighashCache !== sig.hashType || !hashCache || !scriptCache
-                ? getHashForSig(inputIndex, Object.assign({}, input, {
+                ? this.#lazySigner.getHashForSig(inputIndex, Object.assign({}, input, {
                     sighashType: sig.hashType,
-                }), this.#cache, true)
+                }), true)
                 : { hash: hashCache, script: scriptCache };
             sighashCache = sig.hashType;
             hashCache = hash;
@@ -652,22 +608,22 @@ export class Psbt {
     }
     #validateSignaturesOfTaprootInput(inputIndex, validator, pubkey) {
         const input = this.data.inputs[inputIndex];
-        const tapKeySig = (input || {}).tapKeySig;
-        const tapScriptSig = (input || {}).tapScriptSig;
+        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');
         const xPubkey = pubkey ? toXOnly(pubkey) : undefined;
         const allHashses = xPubkey
-            ? getTaprootHashesForSig(inputIndex, input, this.data.inputs, xPubkey, this.#cache)
-            : getAllTaprootHashesForSig(inputIndex, input, this.data.inputs, this.#cache);
+            ? this.#lazySigner.getTaprootHashesForSig(inputIndex, input, this.data.inputs, xPubkey)
+            : this.#lazySigner.getAllTaprootHashesForSig(inputIndex, input, this.data.inputs);
         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));
+            const isValidTapkeySig = validator(tapKeyHash.pubkey, tapKeyHash.hash, this.#lazySigner.trimTaprootSig(tapKeySig));
             if (!isValidTapkeySig)
                 return false;
             validationResultCount++;
@@ -677,7 +633,7 @@ export class Psbt {
                 const tapSigPubkey = tapSig.pubkey;
                 const tapSigHash = allHashses.find((h) => equals(tapSigPubkey, h.pubkey));
                 if (tapSigHash) {
-                    const isValidTapScriptSig = validator(tapSigPubkey, tapSigHash.hash, trimTaprootSig(tapSig.signature));
+                    const isValidTapScriptSig = validator(tapSigPubkey, tapSigHash.hash, this.#lazySigner.trimTaprootSig(tapSig.signature));
                     if (!isValidTapScriptSig)
                         return false;
                     validationResultCount++;
@@ -690,7 +646,7 @@ export class Psbt {
         const pubkey = keyPair.publicKey instanceof Uint8Array
             ? keyPair.publicKey
             : new Uint8Array(keyPair.publicKey);
-        const { hash, sighashType } = getHashAndSighashType(this.data.inputs, inputIndex, pubkey, this.#cache, sighashTypes);
+        const { hash, sighashType } = this.#lazySigner.getHashAndSighashType(this.data.inputs, inputIndex, pubkey, sighashTypes);
         const sig = keyPair.sign(hash);
         const partialSig = [
             {
@@ -708,7 +664,6 @@ export class Psbt {
             : new Uint8Array(keyPair.publicKey));
         if (!('signSchnorr' in keyPair) || typeof keyPair.signSchnorr !== 'function')
             throw new Error(`Need Schnorr Signer to sign taproot input #${inputIndex}.`);
-        // checkTaprootHashesForSig validates signSchnorr exists
         const hashesForSig = this.checkTaprootHashesForSig(inputIndex, input, keyPair, tapLeafHashToSign, allowedSighashTypes);
         const signSchnorr = keyPair.signSchnorr.bind(keyPair);
         const tapKeySig = hashesForSig
@@ -731,22 +686,21 @@ export class Psbt {
         }
         return this;
     }
-    #signInputAsync(inputIndex, keyPair, sighashTypes = [Transaction.SIGHASH_ALL]) {
+    async #signInputAsync(inputIndex, keyPair, sighashTypes = [Transaction.SIGHASH_ALL]) {
         const pubkey = keyPair.publicKey instanceof Uint8Array
             ? keyPair.publicKey
             : new Uint8Array(keyPair.publicKey);
-        const { hash, sighashType } = getHashAndSighashType(this.data.inputs, inputIndex, pubkey, this.#cache, sighashTypes);
-        return Promise.resolve(keyPair.sign(hash)).then((signature) => {
-            const sig = signature instanceof Uint8Array ? signature : new Uint8Array(signature);
-            const partialSig = [
-                {
-                    pubkey,
-                    signature: bscript.signature.encode(sig, sighashType),
-                },
-            ];
-            this.data.updateInput(inputIndex, { partialSig });
-            this.#cache.hasSignatures = true;
-        });
+        const { hash, sighashType } = this.#lazySigner.getHashAndSighashType(this.data.inputs, inputIndex, pubkey, sighashTypes);
+        const signature = await keyPair.sign(hash);
+        const sig = signature instanceof Uint8Array ? signature : new Uint8Array(signature);
+        const partialSig = [
+            {
+                pubkey,
+                signature: bscript.signature.encode(sig, sighashType),
+            },
+        ];
+        this.data.updateInput(inputIndex, { partialSig });
+        this.#cache.hasSignatures = true;
     }
     async #signTaprootInputAsync(inputIndex, input, keyPair, tapLeafHash, sighashTypes = [Transaction.SIGHASH_DEFAULT]) {
         const pubkey = (keyPair.publicKey instanceof Uint8Array
@@ -754,610 +708,28 @@ export class Psbt {
             : new Uint8Array(keyPair.publicKey));
         if (!('signSchnorr' in keyPair) || typeof keyPair.signSchnorr !== 'function')
             throw new Error(`Need Schnorr Signer to sign taproot input #${inputIndex}.`);
-        // checkTaprootHashesForSig validates signSchnorr exists
         const hashesForSig = this.checkTaprootHashesForSig(inputIndex, input, keyPair, tapLeafHash, sighashTypes);
         const signSchnorr = keyPair.signSchnorr.bind(keyPair);
-        const signaturePromises = [];
-        const tapKeyHash = hashesForSig.filter((h) => !h.leafHash)[0];
+        const tapKeyHash = hashesForSig.find((h) => !h.leafHash);
         if (tapKeyHash) {
-            const tapKeySigPromise = Promise.resolve(signSchnorr(tapKeyHash.hash)).then((sig) => {
-                return {
-                    tapKeySig: serializeTaprootSignature(sig, input.sighashType),
-                };
-            });
-            signaturePromises.push(tapKeySigPromise);
+            const sig = await signSchnorr(tapKeyHash.hash);
+            const tapKeySig = serializeTaprootSignature(sig, input.sighashType);
+            this.data.updateInput(inputIndex, { tapKeySig });
+            this.#cache.hasSignatures = true;
         }
         const tapScriptHashes = hashesForSig.filter((h) => !!h.leafHash);
         if (tapScriptHashes.length) {
-            const tapScriptSigPromises = tapScriptHashes.map(async (tsh) => {
+            const tapScriptSigs = await Promise.all(tapScriptHashes.map(async (tsh) => {
                 const signature = await signSchnorr(tsh.hash);
-                const tapScriptSig = [
-                    {
-                        pubkey: toXOnly(pubkey),
-                        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);
+                return {
+                    pubkey: toXOnly(pubkey),
+                    signature: serializeTaprootSignature(signature, input.sighashType),
+                    leafHash: tsh.leafHash,
+                };
+            }));
+            this.data.updateInput(inputIndex, { tapScriptSig: tapScriptSigs });
             this.#cache.hasSignatures = true;
         }
     }
 }
-/**
- * This function is needed to pass to the bip174 base class's fromBuffer.
- * It takes the "transaction buffer" portion of the psbt buffer and returns a
- * Transaction (From the bip174 library) interface.
- */
-const transactionFromBuffer = (buffer) => new PsbtTransaction(buffer);
-/**
- * This class implements the Transaction interface from bip174 library.
- * It contains a bitcoinjs-lib Transaction object.
- */
-class PsbtTransaction {
-    tx;
-    constructor(buffer = new Uint8Array([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 ||
-            (!(input.hash instanceof Uint8Array) && typeof input.hash !== 'string') ||
-            typeof input.index !== 'number') {
-            throw new Error('Error adding input.');
-        }
-        const hash = (typeof input.hash === 'string' ? reverse(fromHex(input.hash)) : input.hash);
-        this.tx.addInput(hash, input.index, input.sequence);
-    }
-    addOutput(output) {
-        if (output.script === undefined ||
-            output.value === undefined ||
-            !(output.script instanceof Uint8Array) ||
-            typeof output.value !== 'bigint') {
-            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,
-            });
-            if (p2ms.m === undefined)
-                throw new Error('Cannot determine m for multisig');
-            return hasSigs(p2ms.m, input.partialSig, p2ms.pubkeys);
-        }
-        case 'nonstandard':
-            return true;
-        default:
-            return false;
-    }
-}
-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) => equals(pSig.pubkey, pubkey));
-        })
-            .filter((v) => !!v);
-    }
-    else {
-        sigs = partialSig;
-    }
-    if (sigs.length > neededSigs)
-        throw new Error('Too many signatures');
-    return sigs.length === neededSigs;
-}
-function bip32DerivationIsMine(root) {
-    return (d) => {
-        const fingerprint = root.fingerprint instanceof Uint8Array
-            ? root.fingerprint
-            : new Uint8Array(root.fingerprint);
-        if (!equals(d.masterFingerprint, fingerprint))
-            return false;
-        const derivedPubkey = root.derivePath(d.path).publicKey;
-        const pubkey = derivedPubkey instanceof Uint8Array ? derivedPubkey : new Uint8Array(derivedPubkey);
-        if (!equals(pubkey, d.pubkey))
-            return false;
-        return true;
-    };
-}
-function checkFees(psbt, cache, opts) {
-    const feeRate = cache.feeRate || psbt.getFeeRate();
-    if (!cache.extractedTx)
-        throw new Error('Transaction not extracted');
-    const vsize = cache.extractedTx.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 getTxCacheValue(key, name, inputs, c, disableOutputChecks = false) {
-    if (!inputs.every(isFinalized))
-        throw new Error(`PSBT must be finalized to calculate ${name}`);
-    if (key === 'feeRate' && c.feeRate)
-        return c.feeRate;
-    if (key === 'fee' && c.fee)
-        return c.fee;
-    let tx;
-    let mustFinalize = true;
-    if (c.extractedTx) {
-        tx = c.extractedTx;
-        mustFinalize = false;
-    }
-    else {
-        tx = c.tx.clone();
-    }
-    inputFinalizeGetAmts(inputs, tx, c, mustFinalize, disableOutputChecks);
-    const value = key === 'feeRate' ? c.feeRate : c.fee;
-    if (value === undefined)
-        throw new Error(`Failed to calculate ${name}`);
-    return value;
-}
-export function getFinalScripts(inputIndex, input, script, isSegwit, isP2SH, isP2WSH, canRunChecks = true, solution) {
-    const scriptType = classifyScript(script);
-    if (!canFinalize(input, script, scriptType) && canRunChecks) {
-        throw new Error(`Can not finalize input #${inputIndex}`);
-    }
-    if (!input.partialSig)
-        throw new Error('Input missing partial signatures');
-    return prepareFinalScripts(script, scriptType, input.partialSig, isSegwit, isP2SH, isP2WSH, solution);
-}
-export function prepareFinalScripts(script, scriptType, partialSig, isSegwit, isP2SH, isP2WSH, solution) {
-    let finalScriptSig;
-    let finalScriptWitness;
-    // Wow, the payments API is very handy
-    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 && p2wsh.witness) {
-            finalScriptWitness = witnessStackToScriptWitness(p2wsh.witness);
-        }
-        else if (payment && payment.witness) {
-            finalScriptWitness = witnessStackToScriptWitness(payment.witness);
-        }
-        else {
-            // nonstandard segwit script
-            finalScriptWitness = witnessStackToScriptWitness(solution ?? [new Uint8Array([0x00])]);
-        }
-        if (p2sh) {
-            finalScriptSig = p2sh?.input;
-        }
-    }
-    else {
-        if (p2sh) {
-            finalScriptSig = p2sh?.input;
-        }
-        else {
-            if (!payment) {
-                finalScriptSig = (Array.isArray(solution) && solution[0] ? solution[0] : new Uint8Array([0x01]));
-            }
-            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 a non-witness UTXO is provided, its hash must match the hash specified in the prevout
-        if (!equals(prevoutHash, 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 = {
-            script: input.witnessUtxo.script,
-            value: input.witnessUtxo.value,
-        };
-    }
-    else {
-        throw new Error('Need a Utxo input item for signing');
-    }
-    const { meaningfulScript, type } = getMeaningfulScript(prevout.script, inputIndex, 'input', input.redeemScript, input.witnessScript);
-    const script = meaningfulScript;
-    if (['p2sh-p2wsh', 'p2wsh'].indexOf(type) >= 0) {
-        hash = unsignedTx.hashForWitnessV0(inputIndex, script, prevout.value, sighashType);
-    }
-    else if (isP2WPKH(meaningfulScript)) {
-        // P2WPKH uses the P2PKH template for prevoutScript when signing
-        const p2pkhPayment = payments.p2pkh({
-            hash: meaningfulScript.subarray(2),
-        });
-        if (!p2pkhPayment.output)
-            throw new Error('Unable to create signing script');
-        hash = unsignedTx.hashForWitnessV0(inputIndex, p2pkhPayment.output, prevout.value, sighashType);
-    }
-    else {
-        // non-segwit
-        if (input.nonWitnessUtxo === undefined && !cache.unsafeSignNonSegwit)
-            throw new Error(`Input #${inputIndex} has witnessUtxo but non-segwit script: ` +
-                toHex(meaningfulScript));
-        if (!forValidate && cache.unsafeSignNonSegwit)
-            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, script, sighashType);
-    }
-    return {
-        script,
-        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);
-    if (!cache.prevOuts) {
-        const prevOuts = inputs.map((i, index) => getScriptAndAmountFromUtxo(index, i, cache));
-        cache.prevOuts = prevOuts;
-        cache.signingScripts = prevOuts.map((o) => o.script);
-        cache.values = prevOuts.map((o) => o.value);
-    }
-    const signingScripts = cache.signingScripts;
-    const values = cache.values;
-    // Compute taproot hash cache once for all inputs (O(n) -> O(1) per input)
-    if (!cache.taprootHashCache) {
-        cache.taprootHashCache = unsignedTx.getTaprootHashCache(signingScripts, values);
-    }
-    const taprootCache = cache.taprootHashCache;
-    const hashes = [];
-    if (input.tapInternalKey && !tapLeafHashToSign) {
-        const outputKey = getPrevoutTaprootKey(inputIndex, input, cache) || new Uint8Array(0);
-        if (equals(toXOnly(pubkey), outputKey)) {
-            const tapKeyHash = unsignedTx.hashForWitnessV1(inputIndex, signingScripts, values, sighashType, undefined, undefined, taprootCache);
-            hashes.push({ pubkey: 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 || equals(tapLeafHashToSign, tapLeaf.hash))
-        .map((tapLeaf) => {
-        const tapScriptHash = unsignedTx.hashForWitnessV1(inputIndex, signingScripts, values, sighashType, tapLeaf.hash, undefined, taprootCache);
-        return {
-            pubkey: 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) {
-    const scriptBranded = script;
-    switch (scriptType) {
-        case 'multisig': {
-            const sigs = getSortedSigs(script, partialSig);
-            return payments.p2ms({
-                output: scriptBranded,
-                signatures: sigs,
-            });
-        }
-        case 'pubkey':
-            return payments.p2pk({
-                output: scriptBranded,
-                signature: partialSig[0].signature,
-            });
-        case 'pubkeyhash':
-            return payments.p2pkh({
-                output: scriptBranded,
-                pubkey: partialSig[0].pubkey,
-                signature: partialSig[0].signature,
-            });
-        case 'witnesspubkeyhash':
-            return payments.p2wpkh({
-                output: scriptBranded,
-                pubkey: partialSig[0].pubkey,
-                signature: partialSig[0].signature,
-            });
-        default:
-            throw new Error(`Unknown script type: ${scriptType}`);
-    }
-}
-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 || (res.script && isP2WPKH(res.script))) {
-        res.isSegwit = true;
-    }
-    else {
-        try {
-            const output = res.script;
-            if (!output)
-                throw new TypeError('Invalid script for segwit address');
-            res.isSegwit = isUnknownSegwitVersion(output);
-        }
-        catch (e) { }
-    }
-    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 (equals(bipDv.masterFingerprint, 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 (!equals(bipDv.pubkey, node.publicKey)) {
-            throw new Error('pubkey did not match bip32Derivation');
-        }
-        return node;
-    });
-}
-function getSortedSigs(script, partialSig) {
-    const p2ms = payments.p2ms({ output: script });
-    if (!p2ms.pubkeys)
-        throw new Error('Cannot extract pubkeys from multisig script');
-    // for each pubkey in order of p2ms script
-    const result = [];
-    for (const pk of p2ms.pubkeys) {
-        // filter partialSig array by pubkey being equal
-        const matched = partialSig.filter((ps) => {
-            return equals(ps.pubkey, pk);
-        })[0];
-        if (matched) {
-            result.push(new Uint8Array(matched.signature));
-        }
-    }
-    return result;
-}
-function addNonWitnessTxCache(cache, input, inputIndex) {
-    if (!input.nonWitnessUtxo)
-        throw new Error('nonWitnessUtxo is required');
-    // Prevent prototype pollution - ensure input is a valid object
-    if (input === null || input === Object.prototype) {
-        throw new Error('Invalid input object');
-    }
-    const nonWitnessUtxoBuf = input.nonWitnessUtxo;
-    cache.nonWitnessUtxoBufCache[inputIndex] = nonWitnessUtxoBuf;
-    cache.nonWitnessUtxoTxCache[inputIndex] = Transaction.fromBuffer(nonWitnessUtxoBuf);
-    const self = cache;
-    const selfIndex = inputIndex;
-    delete input.nonWitnessUtxo;
-    // Using Reflect.defineProperty to avoid prototype pollution concerns
-    Reflect.defineProperty(input, 'nonWitnessUtxo', {
-        enumerable: true,
-        get() {
-            const buf = self.nonWitnessUtxoBufCache[selfIndex];
-            const txCache = self.nonWitnessUtxoTxCache[selfIndex];
-            if (buf !== undefined) {
-                return buf;
-            }
-            else {
-                const newBuf = txCache.toBuffer();
-                self.nonWitnessUtxoBufCache[selfIndex] = newBuf;
-                return newBuf;
-            }
-        },
-        set(data) {
-            self.nonWitnessUtxoBufCache[selfIndex] = data;
-        },
-    });
-}
-function inputFinalizeGetAmts(inputs, tx, cache, mustFinalize, disableOutputChecks) {
-    let inputAmount = 0n;
-    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, 0n);
-    const fee = inputAmount - outputAmount;
-    if (!disableOutputChecks) {
-        if (fee < 0n) {
-            throw new Error(`Outputs are spending more than Inputs ${inputAmount} < ${outputAmount}`);
-        }
-    }
-    const bytes = tx.virtualSize();
-    cache.fee = Number(fee);
-    cache.extractedTx = tx;
-    cache.feeRate = Math.floor(Number(fee) / bytes);
-}
-function nonWitnessUtxoTxFromCache(cache, input, inputIndex) {
-    const c = cache.nonWitnessUtxoTxCache;
-    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 (!(lastItem instanceof Uint8Array) || 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;
-}
 //# sourceMappingURL=psbt.js.map