diff --git a/src/psbt.cpp b/src/psbt.cpp
index 27b39def4..b0b7c3ab9 100644
--- a/src/psbt.cpp
+++ b/src/psbt.cpp
@@ -1,247 +1,258 @@
 // Copyright (c) 2009-2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <psbt.h>
 #include <util/strencodings.h>
 
 PartiallySignedTransaction::PartiallySignedTransaction(const CTransaction &txIn)
     : tx(txIn) {
     inputs.resize(txIn.vin.size());
     outputs.resize(txIn.vout.size());
 }
 
 bool PartiallySignedTransaction::IsNull() const {
     return !tx && inputs.empty() && outputs.empty() && unknown.empty();
 }
 
 bool PartiallySignedTransaction::Merge(const PartiallySignedTransaction &psbt) {
     // Prohibited to merge two PSBTs over different transactions
     if (tx->GetId() != psbt.tx->GetId()) {
         return false;
     }
 
     for (size_t i = 0; i < inputs.size(); ++i) {
         inputs[i].Merge(psbt.inputs[i]);
     }
     for (size_t i = 0; i < outputs.size(); ++i) {
         outputs[i].Merge(psbt.outputs[i]);
     }
     unknown.insert(psbt.unknown.begin(), psbt.unknown.end());
 
     return true;
 }
 
 bool PartiallySignedTransaction::IsSane() const {
     for (PSBTInput input : inputs) {
         if (!input.IsSane()) {
             return false;
         }
     }
     return true;
 }
 
 bool PartiallySignedTransaction::AddInput(const CTxIn &txin,
                                           PSBTInput &psbtin) {
     if (std::find(tx->vin.begin(), tx->vin.end(), txin) != tx->vin.end()) {
         return false;
     }
     tx->vin.push_back(txin);
     psbtin.partial_sigs.clear();
     psbtin.final_script_sig.clear();
     inputs.push_back(psbtin);
     return true;
 }
 
 bool PartiallySignedTransaction::AddOutput(const CTxOut &txout,
                                            const PSBTOutput &psbtout) {
     tx->vout.push_back(txout);
     outputs.push_back(psbtout);
     return true;
 }
 
+bool PartiallySignedTransaction::GetInputUTXO(CTxOut &utxo,
+                                              int input_index) const {
+    PSBTInput input = inputs[input_index];
+    if (!input.utxo.IsNull()) {
+        utxo = input.utxo;
+    } else {
+        return false;
+    }
+    return true;
+}
+
 bool PSBTInput::IsNull() const {
     return utxo.IsNull() && partial_sigs.empty() && unknown.empty() &&
            hd_keypaths.empty() && redeem_script.empty();
 }
 
 void PSBTInput::FillSignatureData(SignatureData &sigdata) const {
     if (!final_script_sig.empty()) {
         sigdata.scriptSig = final_script_sig;
         sigdata.complete = true;
     }
     if (sigdata.complete) {
         return;
     }
 
     sigdata.signatures.insert(partial_sigs.begin(), partial_sigs.end());
     if (!redeem_script.empty()) {
         sigdata.redeem_script = redeem_script;
     }
     for (const auto &key_pair : hd_keypaths) {
         sigdata.misc_pubkeys.emplace(key_pair.first.GetID(), key_pair);
     }
 }
 
 void PSBTInput::FromSignatureData(const SignatureData &sigdata) {
     if (sigdata.complete) {
         partial_sigs.clear();
         hd_keypaths.clear();
         redeem_script.clear();
 
         if (!sigdata.scriptSig.empty()) {
             final_script_sig = sigdata.scriptSig;
         }
         return;
     }
 
     partial_sigs.insert(sigdata.signatures.begin(), sigdata.signatures.end());
     if (redeem_script.empty() && !sigdata.redeem_script.empty()) {
         redeem_script = sigdata.redeem_script;
     }
     for (const auto &entry : sigdata.misc_pubkeys) {
         hd_keypaths.emplace(entry.second);
     }
 }
 
 void PSBTInput::Merge(const PSBTInput &input) {
     if (utxo.IsNull() && !input.utxo.IsNull()) {
         utxo = input.utxo;
     }
 
     partial_sigs.insert(input.partial_sigs.begin(), input.partial_sigs.end());
     hd_keypaths.insert(input.hd_keypaths.begin(), input.hd_keypaths.end());
     unknown.insert(input.unknown.begin(), input.unknown.end());
 
     if (redeem_script.empty() && !input.redeem_script.empty()) {
         redeem_script = input.redeem_script;
     }
     if (final_script_sig.empty() && !input.final_script_sig.empty()) {
         final_script_sig = input.final_script_sig;
     }
 }
 
 bool PSBTInput::IsSane() const {
     return true;
 }
 
 void PSBTOutput::FillSignatureData(SignatureData &sigdata) const {
     if (!redeem_script.empty()) {
         sigdata.redeem_script = redeem_script;
     }
     for (const auto &key_pair : hd_keypaths) {
         sigdata.misc_pubkeys.emplace(key_pair.first.GetID(), key_pair);
     }
 }
 
 void PSBTOutput::FromSignatureData(const SignatureData &sigdata) {
     if (redeem_script.empty() && !sigdata.redeem_script.empty()) {
         redeem_script = sigdata.redeem_script;
     }
     for (const auto &entry : sigdata.misc_pubkeys) {
         hd_keypaths.emplace(entry.second);
     }
 }
 
 bool PSBTOutput::IsNull() const {
     return redeem_script.empty() && hd_keypaths.empty() && unknown.empty();
 }
 
 void PSBTOutput::Merge(const PSBTOutput &output) {
     hd_keypaths.insert(output.hd_keypaths.begin(), output.hd_keypaths.end());
     unknown.insert(output.unknown.begin(), output.unknown.end());
 
     if (redeem_script.empty() && !output.redeem_script.empty()) {
         redeem_script = output.redeem_script;
     }
 }
 
 bool PSBTInputSigned(PSBTInput &input) {
     return !input.final_script_sig.empty();
 }
 
 bool SignPSBTInput(const SigningProvider &provider,
                    PartiallySignedTransaction &psbt, int index,
                    SigHashType sighash) {
     PSBTInput &input = psbt.inputs.at(index);
     const CMutableTransaction &tx = *psbt.tx;
 
     if (PSBTInputSigned(input)) {
         return true;
     }
 
     // Fill SignatureData with input info
     SignatureData sigdata;
     input.FillSignatureData(sigdata);
 
     // Get UTXO
     CTxOut utxo;
 
     // Verify input sanity
     if (!input.IsSane()) {
         return false;
     }
 
     if (input.utxo.IsNull()) {
         return false;
     }
 
     utxo = input.utxo;
     MutableTransactionSignatureCreator creator(&tx, index, utxo.nValue,
                                                sighash);
     bool sig_complete =
         ProduceSignature(provider, creator, utxo.scriptPubKey, sigdata);
     input.FromSignatureData(sigdata);
 
     return sig_complete;
 }
 
 bool FinalizePSBT(PartiallySignedTransaction &psbtx) {
     // Finalize input signatures -- in case we have partial signatures that add
     // up to a complete
     //   signature, but have not combined them yet (e.g. because the combiner
     //   that created this PartiallySignedTransaction did not understand them),
     //   this will combine them into a final script.
     bool complete = true;
     for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
         complete &=
             SignPSBTInput(DUMMY_SIGNING_PROVIDER, psbtx, i, SigHashType());
     }
 
     return complete;
 }
 
 bool FinalizeAndExtractPSBT(PartiallySignedTransaction &psbtx,
                             CMutableTransaction &result) {
     // It's not safe to extract a PSBT that isn't finalized, and there's no easy
     // way to check
     //   whether a PSBT is finalized without finalizing it, so we just do this.
     if (!FinalizePSBT(psbtx)) {
         return false;
     }
 
     result = *psbtx.tx;
     for (size_t i = 0; i < result.vin.size(); ++i) {
         result.vin[i].scriptSig = psbtx.inputs[i].final_script_sig;
     }
     return true;
 }
 
 TransactionError
 CombinePSBTs(PartiallySignedTransaction &out,
              const std::vector<PartiallySignedTransaction> &psbtxs) {
     // Copy the first one
     out = psbtxs[0];
 
     // Merge
     for (auto it = std::next(psbtxs.begin()); it != psbtxs.end(); ++it) {
         if (!out.Merge(*it)) {
             return TransactionError::PSBT_MISMATCH;
         }
     }
     if (!out.IsSane()) {
         return TransactionError::INVALID_PSBT;
     }
 
     return TransactionError::OK;
 }
diff --git a/src/psbt.h b/src/psbt.h
index 4ea795127..f83c00ddd 100644
--- a/src/psbt.h
+++ b/src/psbt.h
@@ -1,520 +1,528 @@
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_PSBT_H
 #define BITCOIN_PSBT_H
 
 #include <attributes.h>
 #include <node/transaction.h>
 #include <primitives/transaction.h>
 #include <pubkey.h>
 #include <script/sign.h>
 
 // Magic bytes
 static constexpr uint8_t PSBT_MAGIC_BYTES[5] = {'p', 's', 'b', 't', 0xff};
 
 // Global types
 static constexpr uint8_t PSBT_GLOBAL_UNSIGNED_TX = 0x00;
 
 // Input types
 static constexpr uint8_t PSBT_IN_UTXO = 0x00;
 static constexpr uint8_t PSBT_IN_PARTIAL_SIG = 0x02;
 static constexpr uint8_t PSBT_IN_SIGHASH = 0x03;
 static constexpr uint8_t PSBT_IN_REDEEMSCRIPT = 0x04;
 static constexpr uint8_t PSBT_IN_BIP32_DERIVATION = 0x06;
 static constexpr uint8_t PSBT_IN_SCRIPTSIG = 0x07;
 
 // Output types
 static constexpr uint8_t PSBT_OUT_REDEEMSCRIPT = 0x00;
 static constexpr uint8_t PSBT_OUT_BIP32_DERIVATION = 0x02;
 
 // The separator is 0x00. Reading this in means that the unserializer can
 // interpret it as a 0 length key which indicates that this is the separator.
 // The separator has no value.
 static constexpr uint8_t PSBT_SEPARATOR = 0x00;
 
 /** A structure for PSBTs which contain per-input information */
 struct PSBTInput {
     CTxOut utxo;
     CScript redeem_script;
     CScript final_script_sig;
     std::map<CPubKey, KeyOriginInfo> hd_keypaths;
     std::map<CKeyID, SigPair> partial_sigs;
     std::map<std::vector<uint8_t>, std::vector<uint8_t>> unknown;
     SigHashType sighash_type = SigHashType(0);
 
     bool IsNull() const;
     void FillSignatureData(SignatureData &sigdata) const;
     void FromSignatureData(const SignatureData &sigdata);
     void Merge(const PSBTInput &input);
     bool IsSane() const;
     PSBTInput() {}
 
     template <typename Stream> inline void Serialize(Stream &s) const {
         // Write the utxo
         if (!utxo.IsNull()) {
             SerializeToVector(s, PSBT_IN_UTXO);
             SerializeToVector(s, utxo);
         }
 
         if (final_script_sig.empty()) {
             // Write any partial signatures
             for (auto sig_pair : partial_sigs) {
                 SerializeToVector(s, PSBT_IN_PARTIAL_SIG,
                                   MakeSpan(sig_pair.second.first));
                 s << sig_pair.second.second;
             }
 
             // Write the sighash type
             if (sighash_type.getRawSigHashType() != 0) {
                 SerializeToVector(s, PSBT_IN_SIGHASH);
                 SerializeToVector(s, sighash_type);
             }
 
             // Write the redeem script
             if (!redeem_script.empty()) {
                 SerializeToVector(s, PSBT_IN_REDEEMSCRIPT);
                 s << redeem_script;
             }
 
             // Write any hd keypaths
             SerializeHDKeypaths(s, hd_keypaths, PSBT_IN_BIP32_DERIVATION);
         }
 
         // Write script sig
         if (!final_script_sig.empty()) {
             SerializeToVector(s, PSBT_IN_SCRIPTSIG);
             s << final_script_sig;
         }
 
         // Write unknown things
         for (auto &entry : unknown) {
             s << entry.first;
             s << entry.second;
         }
 
         s << PSBT_SEPARATOR;
     }
 
     template <typename Stream> inline void Unserialize(Stream &s) {
         // Read loop
         while (!s.empty()) {
             // Read
             std::vector<uint8_t> key;
             s >> key;
 
             // the key is empty if that was actually a separator byte
             // This is a special case for key lengths 0 as those are not allowed
             // (except for separator)
             if (key.empty()) {
                 return;
             }
 
             // First byte of key is the type
             uint8_t type = key[0];
 
             // Do stuff based on type
             switch (type) {
                 case PSBT_IN_UTXO:
                     if (!utxo.IsNull()) {
                         throw std::ios_base::failure(
                             "Duplicate Key, input utxo already provided");
                     } else if (key.size() != 1) {
                         throw std::ios_base::failure(
                             "utxo key is more than one byte type");
                     }
                     UnserializeFromVector(s, utxo);
                     break;
                 case PSBT_IN_PARTIAL_SIG: {
                     // Make sure that the key is the size of pubkey + 1
                     if (key.size() != CPubKey::PUBLIC_KEY_SIZE + 1 &&
                         key.size() != CPubKey::COMPRESSED_PUBLIC_KEY_SIZE + 1) {
                         throw std::ios_base::failure(
                             "Size of key was not the expected size for the "
                             "type partial signature pubkey");
                     }
                     // Read in the pubkey from key
                     CPubKey pubkey(key.begin() + 1, key.end());
                     if (!pubkey.IsFullyValid()) {
                         throw std::ios_base::failure("Invalid pubkey");
                     }
                     if (partial_sigs.count(pubkey.GetID()) > 0) {
                         throw std::ios_base::failure(
                             "Duplicate Key, input partial signature for pubkey "
                             "already provided");
                     }
 
                     // Read in the signature from value
                     std::vector<uint8_t> sig;
                     s >> sig;
 
                     // Add to list
                     partial_sigs.emplace(pubkey.GetID(),
                                          SigPair(pubkey, std::move(sig)));
                     break;
                 }
                 case PSBT_IN_SIGHASH:
                     if (sighash_type.getRawSigHashType() != 0) {
                         throw std::ios_base::failure(
                             "Duplicate Key, input sighash type already "
                             "provided");
                     } else if (key.size() != 1) {
                         throw std::ios_base::failure(
                             "Sighash type key is more than one byte type");
                     }
                     UnserializeFromVector(s, sighash_type);
                     break;
                 case PSBT_IN_REDEEMSCRIPT: {
                     if (!redeem_script.empty()) {
                         throw std::ios_base::failure(
                             "Duplicate Key, input redeemScript already "
                             "provided");
                     } else if (key.size() != 1) {
                         throw std::ios_base::failure(
                             "Input redeemScript key is more than one byte "
                             "type");
                     }
                     s >> redeem_script;
                     break;
                 }
                 case PSBT_IN_BIP32_DERIVATION: {
                     DeserializeHDKeypaths(s, key, hd_keypaths);
                     break;
                 }
                 case PSBT_IN_SCRIPTSIG: {
                     if (!final_script_sig.empty()) {
                         throw std::ios_base::failure(
                             "Duplicate Key, input final scriptSig already "
                             "provided");
                     } else if (key.size() != 1) {
                         throw std::ios_base::failure(
                             "Final scriptSig key is more than one byte type");
                     }
                     s >> final_script_sig;
                     break;
                 }
                 // Unknown stuff
                 default:
                     if (unknown.count(key) > 0) {
                         throw std::ios_base::failure(
                             "Duplicate Key, key for unknown value already "
                             "provided");
                     }
                     // Read in the value
                     std::vector<uint8_t> val_bytes;
                     s >> val_bytes;
                     unknown.emplace(std::move(key), std::move(val_bytes));
                     break;
             }
         }
     }
 
     template <typename Stream> PSBTInput(deserialize_type, Stream &s) {
         Unserialize(s);
     }
 };
 
 /** A structure for PSBTs which contains per output information */
 struct PSBTOutput {
     CScript redeem_script;
     std::map<CPubKey, KeyOriginInfo> hd_keypaths;
     std::map<std::vector<uint8_t>, std::vector<uint8_t>> unknown;
 
     bool IsNull() const;
     void FillSignatureData(SignatureData &sigdata) const;
     void FromSignatureData(const SignatureData &sigdata);
     void Merge(const PSBTOutput &output);
     bool IsSane() const;
     PSBTOutput() {}
 
     template <typename Stream> inline void Serialize(Stream &s) const {
         // Write the redeem script
         if (!redeem_script.empty()) {
             SerializeToVector(s, PSBT_OUT_REDEEMSCRIPT);
             s << redeem_script;
         }
 
         // Write any hd keypaths
         SerializeHDKeypaths(s, hd_keypaths, PSBT_OUT_BIP32_DERIVATION);
 
         // Write unknown things
         for (auto &entry : unknown) {
             s << entry.first;
             s << entry.second;
         }
 
         s << PSBT_SEPARATOR;
     }
 
     template <typename Stream> inline void Unserialize(Stream &s) {
         // Read loop
         while (!s.empty()) {
             // Read
             std::vector<uint8_t> key;
             s >> key;
 
             // the key is empty if that was actually a separator byte
             // This is a special case for key lengths 0 as those are not allowed
             // (except for separator)
             if (key.empty()) {
                 return;
             }
 
             // First byte of key is the type
             uint8_t type = key[0];
 
             // Do stuff based on type
             switch (type) {
                 case PSBT_OUT_REDEEMSCRIPT: {
                     if (!redeem_script.empty()) {
                         throw std::ios_base::failure(
                             "Duplicate Key, output redeemScript already "
                             "provided");
                     } else if (key.size() != 1) {
                         throw std::ios_base::failure(
                             "Output redeemScript key is more than one byte "
                             "type");
                     }
                     s >> redeem_script;
                     break;
                 }
                 case PSBT_OUT_BIP32_DERIVATION: {
                     DeserializeHDKeypaths(s, key, hd_keypaths);
                     break;
                 }
                 // Unknown stuff
                 default: {
                     if (unknown.count(key) > 0) {
                         throw std::ios_base::failure(
                             "Duplicate Key, key for unknown value already "
                             "provided");
                     }
                     // Read in the value
                     std::vector<uint8_t> val_bytes;
                     s >> val_bytes;
                     unknown.emplace(std::move(key), std::move(val_bytes));
                     break;
                 }
             }
         }
     }
 
     template <typename Stream> PSBTOutput(deserialize_type, Stream &s) {
         Unserialize(s);
     }
 };
 
 /**
  * A version of CTransaction with the PSBT format.
  */
 struct PartiallySignedTransaction {
     boost::optional<CMutableTransaction> tx;
     std::vector<PSBTInput> inputs;
     std::vector<PSBTOutput> outputs;
     std::map<std::vector<uint8_t>, std::vector<uint8_t>> unknown;
 
     bool IsNull() const;
 
     /**
      * Merge psbt into this. The two psbts must have the same underlying
      * CTransaction (i.e. the same actual Bitcoin transaction.) Returns true if
      * the merge succeeded, false otherwise.
      */
     NODISCARD bool Merge(const PartiallySignedTransaction &psbt);
     bool IsSane() const;
     bool AddInput(const CTxIn &txin, PSBTInput &psbtin);
     bool AddOutput(const CTxOut &txout, const PSBTOutput &psbtout);
     PartiallySignedTransaction() {}
     PartiallySignedTransaction(const PartiallySignedTransaction &psbt_in)
         : tx(psbt_in.tx), inputs(psbt_in.inputs), outputs(psbt_in.outputs),
           unknown(psbt_in.unknown) {}
     explicit PartiallySignedTransaction(const CTransaction &txIn);
+    /**
+     * Finds the UTXO for a given input index
+     *
+     * @param[out] utxo The UTXO of the input if found
+     * @param[in] input_index Index of the input to retrieve the UTXO of
+     * @return Whether the UTXO for the specified input was found
+     */
+    bool GetInputUTXO(CTxOut &utxo, int input_index) const;
 
     PartiallySignedTransaction &
     operator=(const PartiallySignedTransaction &other) = default;
 
     template <typename Stream> inline void Serialize(Stream &s) const {
         // magic bytes
         s << PSBT_MAGIC_BYTES;
 
         // unsigned tx flag
         SerializeToVector(s, PSBT_GLOBAL_UNSIGNED_TX);
 
         // Write serialized tx to a stream
         SerializeToVector(s, *tx);
 
         // Write the unknown things
         for (auto &entry : unknown) {
             s << entry.first;
             s << entry.second;
         }
 
         // Separator
         s << PSBT_SEPARATOR;
 
         // Write inputs
         for (const PSBTInput &input : inputs) {
             s << input;
         }
 
         // Write outputs
         for (const PSBTOutput &output : outputs) {
             s << output;
         }
     }
 
     template <typename Stream> inline void Unserialize(Stream &s) {
         // Read the magic bytes
         uint8_t magic[5];
         s >> magic;
         if (!std::equal(magic, magic + 5, PSBT_MAGIC_BYTES)) {
             throw std::ios_base::failure("Invalid PSBT magic bytes");
         }
 
         // Read global data
         while (!s.empty()) {
             // Read
             std::vector<uint8_t> key;
             s >> key;
 
             // the key is empty if that was actually a separator byte
             // This is a special case for key lengths 0 as those are not allowed
             // (except for separator)
             if (key.empty()) {
                 break;
             }
 
             // First byte of key is the type
             uint8_t type = key[0];
 
             // Do stuff based on type
             switch (type) {
                 case PSBT_GLOBAL_UNSIGNED_TX: {
                     if (tx) {
                         throw std::ios_base::failure(
                             "Duplicate Key, unsigned tx already provided");
                     } else if (key.size() != 1) {
                         throw std::ios_base::failure(
                             "Global unsigned tx key is more than one byte "
                             "type");
                     }
                     CMutableTransaction mtx;
                     UnserializeFromVector(s, mtx);
                     tx = std::move(mtx);
                     // Make sure that all scriptSigs are empty.
                     for (const CTxIn &txin : tx->vin) {
                         if (!txin.scriptSig.empty()) {
                             throw std::ios_base::failure(
                                 "Unsigned tx does not have empty scriptSigs.");
                         }
                     }
                     break;
                 }
                 // Unknown stuff
                 default: {
                     if (unknown.count(key) > 0) {
                         throw std::ios_base::failure(
                             "Duplicate Key, key for unknown value already "
                             "provided");
                     }
                     // Read in the value
                     std::vector<uint8_t> val_bytes;
                     s >> val_bytes;
                     unknown.emplace(std::move(key), std::move(val_bytes));
                 }
             }
         }
 
         // Make sure that we got an unsigned tx
         if (!tx) {
             throw std::ios_base::failure(
                 "No unsigned transcation was provided");
         }
 
         // Read input data
         size_t i = 0;
         while (!s.empty() && i < tx->vin.size()) {
             PSBTInput input;
             s >> input;
             inputs.push_back(input);
             ++i;
         }
         // Make sure that the number of inputs matches the number of inputs in
         // the transaction
         if (inputs.size() != tx->vin.size()) {
             throw std::ios_base::failure("Inputs provided does not match the "
                                          "number of inputs in transaction.");
         }
 
         // Read output data
         i = 0;
         while (!s.empty() && i < tx->vout.size()) {
             PSBTOutput output;
             s >> output;
             outputs.push_back(output);
             ++i;
         }
         // Make sure that the number of outputs matches the number of outputs in
         // the transaction
         if (outputs.size() != tx->vout.size()) {
             throw std::ios_base::failure("Outputs provided does not match the "
                                          "number of outputs in transaction.");
         }
         // Sanity check
         if (!IsSane()) {
             throw std::ios_base::failure("PSBT is not sane.");
         }
     }
 
     template <typename Stream>
     PartiallySignedTransaction(deserialize_type, Stream &s) {
         Unserialize(s);
     }
 };
 
 /** Checks whether a PSBTInput is already signed. */
 bool PSBTInputSigned(PSBTInput &input);
 
 /**
  * Signs a PSBTInput, verifying that all provided data matches what is being
  * signed.
  */
 bool SignPSBTInput(const SigningProvider &provider,
                    PartiallySignedTransaction &psbt, int index,
                    SigHashType sighash = SigHashType());
 
 /**
  * Finalizes a PSBT if possible, combining partial signatures.
  *
  * @param[in,out] &psbtx reference to PartiallySignedTransaction to finalize
  * return True if the PSBT is now complete, false otherwise
  */
 bool FinalizePSBT(PartiallySignedTransaction &psbtx);
 
 /**
  * Finalizes a PSBT if possible, and extracts it to a CMutableTransaction if it
  * could be finalized.
  *
  * @param[in]  &psbtx reference to PartiallySignedTransaction
  * @param[out] result CMutableTransaction representing the complete transaction,
  * if successful
  * @return True if we successfully extracted the transaction, false otherwise
  */
 bool FinalizeAndExtractPSBT(PartiallySignedTransaction &psbtx,
                             CMutableTransaction &result);
 
 /**
  * Combines PSBTs with the same underlying transaction, resulting in a single
  * PSBT with all partial signatures from each input.
  *
  * @param[out] &out   the combined PSBT, if successful
  * @param[in]  psbtxs the PSBTs to combine
  * @return error (OK if we successfully combined the transactions, other error
  * if they were not compatible)
  */
 NODISCARD TransactionError
 CombinePSBTs(PartiallySignedTransaction &out,
              const std::vector<PartiallySignedTransaction> &psbtxs);
 
 #endif // BITCOIN_PSBT_H