diff --git a/src/psbt.cpp b/src/psbt.cpp
index 0fc495f890..2da7a84948 100644
--- a/src/psbt.cpp
+++ b/src/psbt.cpp
@@ -1,302 +1,445 @@
 // 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 <coins.h>
+#include <consensus/tx_verify.h>
+#include <policy/policy.h>
 #include <psbt.h>
 #include <util/strencodings.h>
 
+#include <numeric>
+
 PartiallySignedTransaction::PartiallySignedTransaction(
     const CMutableTransaction &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) {
+bool PSBTInputSigned(const PSBTInput &input) {
     return !input.final_script_sig.empty();
 }
 
 bool SignPSBTInput(const SigningProvider &provider,
                    PartiallySignedTransaction &psbt, int index,
                    SigHashType sighash, SignatureData *out_sigdata,
                    bool use_dummy) {
     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;
 
     bool sig_complete{false};
     if (use_dummy) {
         sig_complete = ProduceSignature(provider, DUMMY_SIGNATURE_CREATOR,
                                         utxo.scriptPubKey, sigdata);
     } else {
         MutableTransactionSignatureCreator creator(&tx, index, utxo.nValue,
                                                    sighash);
         sig_complete =
             ProduceSignature(provider, creator, utxo.scriptPubKey, sigdata);
     }
     input.FromSignatureData(sigdata);
 
     // Fill in the missing info
     if (out_sigdata != nullptr) {
         out_sigdata->missing_pubkeys = sigdata.missing_pubkeys;
         out_sigdata->missing_sigs = sigdata.missing_sigs;
         out_sigdata->missing_redeem_script = sigdata.missing_redeem_script;
     }
 
     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;
 }
 
+std::string PSBTRoleName(PSBTRole role) {
+    switch (role) {
+        case PSBTRole::UPDATER:
+            return "updater";
+        case PSBTRole::SIGNER:
+            return "signer";
+        case PSBTRole::FINALIZER:
+            return "finalizer";
+        case PSBTRole::EXTRACTOR:
+            return "extractor";
+    }
+}
+
+PSBTAnalysis AnalyzePSBT(PartiallySignedTransaction psbtx) {
+    // Go through each input and build status
+    PSBTAnalysis result;
+
+    bool calc_fee = true;
+    bool all_final = true;
+    bool only_missing_sigs = true;
+    bool only_missing_final = false;
+    Amount in_amt{Amount::zero()};
+
+    result.inputs.resize(psbtx.tx->vin.size());
+
+    for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
+        PSBTInput &input = psbtx.inputs[i];
+        PSBTInputAnalysis &input_analysis = result.inputs[i];
+
+        // Check for a UTXO
+        CTxOut utxo;
+        if (psbtx.GetInputUTXO(utxo, i)) {
+            in_amt += utxo.nValue;
+            input_analysis.has_utxo = true;
+        } else {
+            input_analysis.has_utxo = false;
+            input_analysis.is_final = false;
+            input_analysis.next = PSBTRole::UPDATER;
+            calc_fee = false;
+        }
+
+        // Check if it is final
+        if (!utxo.IsNull() && !PSBTInputSigned(input)) {
+            input_analysis.is_final = false;
+            all_final = false;
+
+            // Figure out what is missing
+            SignatureData outdata;
+            bool complete = SignPSBTInput(DUMMY_SIGNING_PROVIDER, psbtx, i,
+                                          SigHashType().withForkId(), &outdata);
+
+            // Things are missing
+            if (!complete) {
+                input_analysis.missing_pubkeys = outdata.missing_pubkeys;
+                input_analysis.missing_redeem_script =
+                    outdata.missing_redeem_script;
+                input_analysis.missing_sigs = outdata.missing_sigs;
+
+                // If we are only missing signatures and nothing else, then next
+                // is signer
+                if (outdata.missing_pubkeys.empty() &&
+                    outdata.missing_redeem_script.IsNull() &&
+                    !outdata.missing_sigs.empty()) {
+                    input_analysis.next = PSBTRole::SIGNER;
+                } else {
+                    only_missing_sigs = false;
+                    input_analysis.next = PSBTRole::UPDATER;
+                }
+            } else {
+                only_missing_final = true;
+                input_analysis.next = PSBTRole::FINALIZER;
+            }
+        } else if (!utxo.IsNull()) {
+            input_analysis.is_final = true;
+        }
+    }
+
+    if (all_final) {
+        only_missing_sigs = false;
+        result.next = PSBTRole::EXTRACTOR;
+    }
+    if (calc_fee) {
+        // Get the output amount
+        Amount out_amt = std::accumulate(
+            psbtx.tx->vout.begin(), psbtx.tx->vout.end(), Amount::zero(),
+            [](Amount a, const CTxOut &b) { return a += b.nValue; });
+
+        // Get the fee
+        Amount fee = in_amt - out_amt;
+        result.fee = fee;
+
+        // Estimate the size
+        CMutableTransaction mtx(*psbtx.tx);
+        CCoinsView view_dummy;
+        CCoinsViewCache view(&view_dummy);
+        bool success = true;
+
+        for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
+            PSBTInput &input = psbtx.inputs[i];
+            CTxOut newUtxo;
+
+            if (!SignPSBTInput(DUMMY_SIGNING_PROVIDER, psbtx, i,
+                               SigHashType().withForkId(), nullptr, true) ||
+                !psbtx.GetInputUTXO(newUtxo, i)) {
+                success = false;
+                break;
+            } else {
+                mtx.vin[i].scriptSig = input.final_script_sig;
+                view.AddCoin(psbtx.tx->vin[i].prevout, Coin(newUtxo, 1, false),
+                             true);
+            }
+        }
+
+        if (success) {
+            CTransaction ctx = CTransaction(mtx);
+            size_t size = ctx.GetTotalSize();
+            result.estimated_vsize = size;
+            // Estimate fee rate
+            CFeeRate feerate(fee, size);
+            result.estimated_feerate = feerate;
+        }
+
+        if (only_missing_sigs) {
+            result.next = PSBTRole::SIGNER;
+        } else if (only_missing_final) {
+            result.next = PSBTRole::FINALIZER;
+        } else if (all_final) {
+            result.next = PSBTRole::EXTRACTOR;
+        } else {
+            result.next = PSBTRole::UPDATER;
+        }
+    } else {
+        result.next = PSBTRole::UPDATER;
+    }
+
+    return result;
+}
+
 bool DecodeBase64PSBT(PartiallySignedTransaction &psbt,
                       const std::string &base64_tx, std::string &error) {
     bool invalid;
     std::string tx_data = DecodeBase64(base64_tx, &invalid);
     if (invalid) {
         error = "invalid base64";
         return false;
     }
     return DecodeRawPSBT(psbt, tx_data, error);
 }
 
 bool DecodeRawPSBT(PartiallySignedTransaction &psbt, const std::string &tx_data,
                    std::string &error) {
     CDataStream ss_data(tx_data.data(), tx_data.data() + tx_data.size(),
                         SER_NETWORK, PROTOCOL_VERSION);
     try {
         ss_data >> psbt;
         if (!ss_data.empty()) {
             error = "extra data after PSBT";
             return false;
         }
     } catch (const std::exception &e) {
         error = e.what();
         return false;
     }
     return true;
 }
diff --git a/src/psbt.h b/src/psbt.h
index 2ad80fee03..c9fc744782 100644
--- a/src/psbt.h
+++ b/src/psbt.h
@@ -1,538 +1,575 @@
 // 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 <optional.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 CMutableTransaction &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);
     }
 };
 
+enum class PSBTRole {
+    UPDATER,
+    SIGNER,
+    FINALIZER,
+    EXTRACTOR,
+};
+
+struct PSBTInputAnalysis {
+    bool has_utxo;
+    bool is_final;
+    PSBTRole next;
+
+    std::vector<CKeyID> missing_pubkeys;
+    std::vector<CKeyID> missing_sigs;
+    uint160 missing_redeem_script;
+};
+
+struct PSBTAnalysis {
+    Optional<size_t> estimated_vsize;
+    Optional<CFeeRate> estimated_feerate;
+    Optional<Amount> fee;
+    std::vector<PSBTInputAnalysis> inputs;
+    PSBTRole next;
+};
+
+std::string PSBTRoleName(PSBTRole role);
+
 /** Checks whether a PSBTInput is already signed. */
-bool PSBTInputSigned(PSBTInput &input);
+bool PSBTInputSigned(const 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(),
                    SignatureData *out_sigdata = nullptr,
                    bool use_dummy = false);
 
 /**
  * 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);
 
+/**
+ * Provides helpful miscellaneous information about where a PSBT is in the
+ * signing workflow.
+ *
+ * @param[in] psbtx the PSBT to analyze
+ * @return A PSBTAnalysis with information about the provided PSBT.
+ */
+PSBTAnalysis AnalyzePSBT(PartiallySignedTransaction psbtx);
+
 //! Decode a base64ed PSBT into a PartiallySignedTransaction
 NODISCARD bool DecodeBase64PSBT(PartiallySignedTransaction &decoded_psbt,
                                 const std::string &base64_psbt,
                                 std::string &error);
 //! Decode a raw (binary blob) PSBT into a PartiallySignedTransaction
 NODISCARD bool DecodeRawPSBT(PartiallySignedTransaction &decoded_psbt,
                              const std::string &raw_psbt, std::string &error);
 
 #endif // BITCOIN_PSBT_H
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index c3f8b71d77..bf67f2c879 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -1,2073 +1,1979 @@
 // Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 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 <chain.h>
 #include <chainparams.h>
 #include <coins.h>
 #include <compat/byteswap.h>
 #include <config.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <index/txindex.h>
 #include <init.h>
 #include <interfaces/chain.h>
 #include <key_io.h>
 #include <keystore.h>
 #include <merkleblock.h>
 #include <node/transaction.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <psbt.h>
 #include <rpc/rawtransaction_util.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/script.h>
 #include <script/script_error.h>
 #include <script/sign.h>
 #include <script/standard.h>
 #include <txmempool.h>
 #include <uint256.h>
 #include <util/error.h>
 #include <util/strencodings.h>
 #include <validation.h>
 #include <validationinterface.h>
 
 #include <cstdint>
-#include <numeric>
 
 #include <univalue.h>
 
 static void TxToJSON(const CTransaction &tx, const BlockHash &hashBlock,
                      UniValue &entry) {
     // Call into TxToUniv() in bitcoin-common to decode the transaction hex.
     //
     // Blockchain contextual information (confirmations and blocktime) is not
     // available to code in bitcoin-common, so we query them here and push the
     // data into the returned UniValue.
     TxToUniv(tx, uint256(), entry, true, RPCSerializationFlags());
 
     if (!hashBlock.IsNull()) {
         LOCK(cs_main);
 
         entry.pushKV("blockhash", hashBlock.GetHex());
         CBlockIndex *pindex = LookupBlockIndex(hashBlock);
         if (pindex) {
             if (::ChainActive().Contains(pindex)) {
                 entry.pushKV("confirmations",
                              1 + ::ChainActive().Height() - pindex->nHeight);
                 entry.pushKV("time", pindex->GetBlockTime());
                 entry.pushKV("blocktime", pindex->GetBlockTime());
             } else {
                 entry.pushKV("confirmations", 0);
             }
         }
     }
 }
 
 static UniValue getrawtransaction(const Config &config,
                                   const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 3) {
         throw std::runtime_error(RPCHelpMan{
             "getrawtransaction",
             "\nBy default this function only works for mempool "
             "transactions. When called with a blockhash\n"
             "argument, getrawtransaction will return the transaction if "
             "the specified block is available and\n"
             "the transaction is found in that block. When called without a "
             "blockhash argument, getrawtransaction\n"
             "will return the transaction if it is in the mempool, or if "
             "-txindex is enabled and the transaction\n"
             "is in a block in the blockchain.\n"
 
             "\nReturn the raw transaction data.\n"
             "\nIf verbose is 'true', returns an Object with information "
             "about 'txid'.\n"
             "If verbose is 'false' or omitted, returns a string that is "
             "serialized, hex-encoded data for 'txid'.\n",
             {
                 {"txid", RPCArg::Type::STR_HEX, /* opt */ false,
                  /* default_val */ "", "The transaction id"},
                 {"verbose", RPCArg::Type::BOOL, /* opt */ true,
                  /* default_val */ "false",
                  "If false, return a string, otherwise return a json "
                  "object"},
                 {"blockhash", RPCArg::Type::STR_HEX, /* opt */ true,
                  /* default_val */ "",
                  "The block in which to look for the transaction"},
             },
             {
                 RPCResult{"if verbose is not set or set to false",
                           "\"data\"      (string) The serialized, hex-encoded "
                           "data for 'txid'\n"},
                 RPCResult{
                     "if verbose is set to true",
                     "{\n"
                     "  \"in_active_chain\": b, (bool) Whether specified block "
                     "is in the active chain or not (only present with explicit "
                     "\"blockhash\" argument)\n"
                     "  \"hex\" : \"data\",       (string) The serialized, "
                     "hex-encoded data for 'txid'\n"
                     "  \"txid\" : \"id\",        (string) The transaction id "
                     "(same as provided)\n"
                     "  \"hash\" : \"id\",        (string) The transaction hash "
                     "(differs from txid for witness transactions)\n"
                     "  \"size\" : n,             (numeric) The serialized "
                     "transaction size\n"
                     "  \"version\" : n,          (numeric) The version\n"
                     "  \"locktime\" : ttt,       (numeric) The lock time\n"
                     "  \"vin\" : [               (array of json objects)\n"
                     "     {\n"
                     "       \"txid\": \"id\",    (string) The transaction id\n"
                     "       \"vout\": n,         (numeric) \n"
                     "       \"scriptSig\": {     (json object) The script\n"
                     "         \"asm\": \"asm\",  (string) asm\n"
                     "         \"hex\": \"hex\"   (string) hex\n"
                     "       },\n"
                     "       \"sequence\": n      (numeric) The script sequence "
                     "number\n"
                     "     }\n"
                     "     ,...\n"
                     "  ],\n"
                     "  \"vout\" : [              (array of json objects)\n"
                     "     {\n"
                     "       \"value\" : x.xxx,            (numeric) The value "
                     "in " +
                         CURRENCY_UNIT +
                         "\n"
                         "       \"n\" : n,                    (numeric) index\n"
                         "       \"scriptPubKey\" : {          (json object)\n"
                         "         \"asm\" : \"asm\",          (string) the "
                         "asm\n"
                         "         \"hex\" : \"hex\",          (string) the "
                         "hex\n"
                         "         \"reqSigs\" : n,            (numeric) The "
                         "required sigs\n"
                         "         \"type\" : \"pubkeyhash\",  (string) The "
                         "type, eg 'pubkeyhash'\n"
                         "         \"addresses\" : [           (json array of "
                         "string)\n"
                         "           \"address\"        (string) bitcoin "
                         "address\n"
                         "           ,...\n"
                         "         ]\n"
                         "       }\n"
                         "     }\n"
                         "     ,...\n"
                         "  ],\n"
                         "  \"blockhash\" : \"hash\",   (string) the block "
                         "hash\n"
                         "  \"confirmations\" : n,      (numeric) The "
                         "confirmations\n"
                         "  \"time\" : ttt,             (numeric) The "
                         "transaction time in seconds since epoch (Jan 1 1970 "
                         "GMT)\n"
                         "  \"blocktime\" : ttt         (numeric) The block "
                         "time in seconds since epoch (Jan 1 1970 GMT)\n"
                         "}\n"},
             },
             RPCExamples{
                 HelpExampleCli("getrawtransaction", "\"mytxid\"") +
                 HelpExampleCli("getrawtransaction", "\"mytxid\" true") +
                 HelpExampleRpc("getrawtransaction", "\"mytxid\", true") +
                 HelpExampleCli("getrawtransaction",
                                "\"mytxid\" false \"myblockhash\"") +
                 HelpExampleCli("getrawtransaction",
                                "\"mytxid\" true \"myblockhash\"")},
         }
                                      .ToString());
     }
 
     bool in_active_chain = true;
     TxId txid = TxId(ParseHashV(request.params[0], "parameter 1"));
     CBlockIndex *blockindex = nullptr;
 
     const CChainParams &params = config.GetChainParams();
     if (txid == params.GenesisBlock().hashMerkleRoot) {
         // Special exception for the genesis block coinbase transaction
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "The genesis block coinbase is not considered an "
                            "ordinary transaction and cannot be retrieved");
     }
 
     // Accept either a bool (true) or a num (>=1) to indicate verbose output.
     bool fVerbose = false;
     if (!request.params[1].isNull()) {
         fVerbose = request.params[1].isNum()
                        ? (request.params[1].get_int() != 0)
                        : request.params[1].get_bool();
     }
 
     if (!request.params[2].isNull()) {
         LOCK(cs_main);
 
         BlockHash blockhash(ParseHashV(request.params[2], "parameter 3"));
         blockindex = LookupBlockIndex(blockhash);
         if (!blockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Block hash not found");
         }
         in_active_chain = ::ChainActive().Contains(blockindex);
     }
 
     bool f_txindex_ready = false;
     if (g_txindex && !blockindex) {
         f_txindex_ready = g_txindex->BlockUntilSyncedToCurrentChain();
     }
 
     CTransactionRef tx;
     BlockHash hash_block;
     if (!GetTransaction(txid, tx, params.GetConsensus(), hash_block,
                         blockindex)) {
         std::string errmsg;
         if (blockindex) {
             if (!blockindex->nStatus.hasData()) {
                 throw JSONRPCError(RPC_MISC_ERROR, "Block not available");
             }
             errmsg = "No such transaction found in the provided block";
         } else if (!g_txindex) {
             errmsg = "No such mempool transaction. Use -txindex to enable "
                      "blockchain transaction queries";
         } else if (!f_txindex_ready) {
             errmsg = "No such mempool transaction. Blockchain transactions are "
                      "still in the process of being indexed";
         } else {
             errmsg = "No such mempool or blockchain transaction";
         }
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            errmsg +
                                ". Use gettransaction for wallet transactions.");
     }
 
     if (!fVerbose) {
         return EncodeHexTx(*tx, RPCSerializationFlags());
     }
 
     UniValue result(UniValue::VOBJ);
     if (blockindex) {
         result.pushKV("in_active_chain", in_active_chain);
     }
     TxToJSON(*tx, hash_block, result);
     return result;
 }
 
 static UniValue gettxoutproof(const Config &config,
                               const JSONRPCRequest &request) {
     if (request.fHelp ||
         (request.params.size() != 1 && request.params.size() != 2)) {
         throw std::runtime_error(RPCHelpMan{
             "gettxoutproof",
             "\nReturns a hex-encoded proof that \"txid\" was "
             "included in a block.\n"
             "\nNOTE: By default this function only works sometimes. "
             "This is when there is an\n"
             "unspent output in the utxo for this transaction. To "
             "make it always work,\n"
             "you need to maintain a transaction index, using the "
             "-txindex command line option or\n"
             "specify the block in which the transaction is included "
             "manually (by blockhash).\n",
             {
                 {
                     "txids",
                     RPCArg::Type::ARR,
                     /* opt */ false,
                     /* default_val */ "",
                     "A json array of txids to filter",
                     {
                         {"txid", RPCArg::Type::STR_HEX, /* opt */ false,
                          /* default_val */ "", "A transaction hash"},
                     },
                 },
                 {"blockhash", RPCArg::Type::STR_HEX, /* opt */ true,
                  /* default_val */ "",
                  "If specified, looks for txid in the block with this "
                  "hash"},
             },
             RPCResult{"\"data\"           (string) A string that is a "
                       "serialized, hex-encoded data for the proof.\n"},
             RPCExamples{""},
         }
                                      .ToString());
     }
 
     std::set<TxId> setTxIds;
     TxId oneTxId;
     UniValue txids = request.params[0].get_array();
     for (unsigned int idx = 0; idx < txids.size(); idx++) {
         const UniValue &utxid = txids[idx];
         TxId txid(ParseHashV(utxid, "txid"));
         if (setTxIds.count(txid)) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 std::string("Invalid parameter, duplicated txid: ") +
                     utxid.get_str());
         }
 
         setTxIds.insert(txid);
         oneTxId = txid;
     }
 
     CBlockIndex *pblockindex = nullptr;
 
     BlockHash hashBlock;
     if (!request.params[1].isNull()) {
         LOCK(cs_main);
         hashBlock = BlockHash(ParseHashV(request.params[1], "blockhash"));
         pblockindex = LookupBlockIndex(hashBlock);
         if (!pblockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
     } else {
         LOCK(cs_main);
         // Loop through txids and try to find which block they're in. Exit loop
         // once a block is found.
         for (const auto &txid : setTxIds) {
             const Coin &coin = AccessByTxid(*pcoinsTip, txid);
             if (!coin.IsSpent()) {
                 pblockindex = ::ChainActive()[coin.GetHeight()];
                 break;
             }
         }
     }
 
     // Allow txindex to catch up if we need to query it and before we acquire
     // cs_main.
     if (g_txindex && !pblockindex) {
         g_txindex->BlockUntilSyncedToCurrentChain();
     }
 
     const Consensus::Params &params = config.GetChainParams().GetConsensus();
 
     LOCK(cs_main);
 
     if (pblockindex == nullptr) {
         CTransactionRef tx;
         if (!GetTransaction(oneTxId, tx, params, hashBlock) ||
             hashBlock.IsNull()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Transaction not yet in block");
         }
 
         pblockindex = LookupBlockIndex(hashBlock);
         if (!pblockindex) {
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Transaction index corrupt");
         }
     }
 
     CBlock block;
     if (!ReadBlockFromDisk(block, pblockindex, params)) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Can't read block from disk");
     }
 
     unsigned int ntxFound = 0;
     for (const auto &tx : block.vtx) {
         if (setTxIds.count(tx->GetId())) {
             ntxFound++;
         }
     }
 
     if (ntxFound != setTxIds.size()) {
         throw JSONRPCError(
             RPC_INVALID_ADDRESS_OR_KEY,
             "Not all transactions found in specified or retrieved block");
     }
 
     CDataStream ssMB(SER_NETWORK, PROTOCOL_VERSION);
     CMerkleBlock mb(block, setTxIds);
     ssMB << mb;
     std::string strHex = HexStr(ssMB.begin(), ssMB.end());
     return strHex;
 }
 
 static UniValue verifytxoutproof(const Config &config,
                                  const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "verifytxoutproof",
             "\nVerifies that a proof points to a transaction in a "
             "block, returning the transaction it commits to\n"
             "and throwing an RPC error if the block is not in our "
             "best chain\n",
             {
                 {"proof", RPCArg::Type::STR_HEX, /* opt */ false,
                  /* default_val */ "",
                  "The hex-encoded proof generated by gettxoutproof"},
             },
             RPCResult{"[\"txid\"]      (array, strings) The txid(s) which the "
                       "proof commits to, or empty array if the proof can not "
                       "be validated.\n"},
             RPCExamples{""},
         }
                                      .ToString());
     }
 
     CDataStream ssMB(ParseHexV(request.params[0], "proof"), SER_NETWORK,
                      PROTOCOL_VERSION);
     CMerkleBlock merkleBlock;
     ssMB >> merkleBlock;
 
     UniValue res(UniValue::VARR);
 
     std::vector<uint256> vMatch;
     std::vector<size_t> vIndex;
     if (merkleBlock.txn.ExtractMatches(vMatch, vIndex) !=
         merkleBlock.header.hashMerkleRoot) {
         return res;
     }
 
     LOCK(cs_main);
 
     const CBlockIndex *pindex = LookupBlockIndex(merkleBlock.header.GetHash());
     if (!pindex || !::ChainActive().Contains(pindex) || pindex->nTx == 0) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Block not found in chain");
     }
 
     // Check if proof is valid, only add results if so
     if (pindex->nTx == merkleBlock.txn.GetNumTransactions()) {
         for (const uint256 &hash : vMatch) {
             res.push_back(hash.GetHex());
         }
     }
 
     return res;
 }
 
 static UniValue createrawtransaction(const Config &config,
                                      const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 3) {
         throw std::runtime_error(RPCHelpMan{
             "createrawtransaction",
             "\nCreate a transaction spending the given inputs and creating "
             "new outputs.\n"
             "Outputs can be addresses or data.\n"
             "Returns hex-encoded raw transaction.\n"
             "Note that the transaction's inputs are not signed, and\n"
             "it is not stored in the wallet or transmitted to the network.\n",
             {
                 {
                     "inputs",
                     RPCArg::Type::ARR,
                     /* opt */ false,
                     /* default_val */ "",
                     "A json array of json objects",
                     {
                         {
                             "",
                             RPCArg::Type::OBJ,
                             /* opt */ false,
                             /* default_val */ "",
                             "",
                             {
                                 {"txid", RPCArg::Type::STR_HEX,
                                  /* opt */ false, /* default_val */ "",
                                  "The transaction id"},
                                 {"vout", RPCArg::Type::NUM, /* opt */ false,
                                  /* default_val */ "", "The output number"},
                                 {"sequence", RPCArg::Type::NUM,
                                  /* opt */ true, /* default_val */ "",
                                  "The sequence number"},
                             },
                         },
                     },
                 },
                 {
                     "outputs",
                     RPCArg::Type::ARR,
                     /* opt */ false,
                     /* default_val */ "",
                     "a json array with outputs (key-value pairs).\n"
                     "For compatibility reasons, a dictionary, which holds "
                     "the key-value pairs directly, is also\n"
                     "                             accepted as second "
                     "parameter.",
                     {
                         {
                             "",
                             RPCArg::Type::OBJ,
                             /* opt */ true,
                             /* default_val */ "",
                             "",
                             {
                                 {"address", RPCArg::Type::AMOUNT,
                                  /* opt */ false, /* default_val */ "",
                                  "A key-value pair. The key (string) is "
                                  "the bitcoin address, the value (float or "
                                  "string) is the amount in " +
                                      CURRENCY_UNIT},
                             },
                         },
                         {
                             "",
                             RPCArg::Type::OBJ,
                             /* opt */ true,
                             /* default_val */ "",
                             "",
                             {
                                 {"data", RPCArg::Type::STR_HEX,
                                  /* opt */ false, /* default_val */ "",
                                  "A key-value pair. The key must be "
                                  "\"data\", the value is hex-encoded data"},
                             },
                         },
                     },
                 },
                 {"locktime", RPCArg::Type::NUM, /* opt */ true,
                  /* default_val */ "0",
                  "Raw locktime. Non-0 value also locktime-activates "
                  "inputs"},
             },
             RPCResult{"\"transaction\"              (string) hex string of the "
                       "transaction\n"},
             RPCExamples{
                 HelpExampleCli("createrawtransaction",
                                "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                                "\" \"[{\\\"address\\\":0.01}]\"") +
                 HelpExampleCli("createrawtransaction",
                                "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                                "\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"") +
                 HelpExampleRpc("createrawtransaction",
                                "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                                "\", \"[{\\\"address\\\":0.01}]\"") +
                 HelpExampleRpc("createrawtransaction",
                                "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                                "\", \"[{\\\"data\\\":\\\"00010203\\\"}]\"")},
         }
                                      .ToString());
     }
 
     RPCTypeCheck(request.params,
                  {UniValue::VARR,
                   UniValueType(), // ARR or OBJ, checked later
                   UniValue::VNUM},
                  true);
 
     CMutableTransaction rawTx =
         ConstructTransaction(config.GetChainParams(), request.params[0],
                              request.params[1], request.params[2]);
 
     return EncodeHexTx(CTransaction(rawTx));
 }
 
 static UniValue decoderawtransaction(const Config &config,
                                      const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "decoderawtransaction",
             "\nReturn a JSON object representing the serialized, "
             "hex-encoded transaction.\n",
             {
                 {"hexstring", RPCArg::Type::STR_HEX, /* opt */ false,
                  /* default_val */ "", "The transaction hex string"},
             },
             RPCResult{
                 "{\n"
                 "  \"txid\" : \"id\",        (string) The transaction id\n"
                 "  \"hash\" : \"id\",        (string) The transaction hash "
                 "(differs from txid for witness transactions)\n"
                 "  \"size\" : n,             (numeric) The transaction size\n"
                 "  \"version\" : n,          (numeric) The version\n"
                 "  \"locktime\" : ttt,       (numeric) The lock time\n"
                 "  \"vin\" : [               (array of json objects)\n"
                 "     {\n"
                 "       \"txid\": \"id\",    (string) The transaction id\n"
                 "       \"vout\": n,         (numeric) The output number\n"
                 "       \"scriptSig\": {     (json object) The script\n"
                 "         \"asm\": \"asm\",  (string) asm\n"
                 "         \"hex\": \"hex\"   (string) hex\n"
                 "       },\n"
                 "       \"sequence\": n     (numeric) The script sequence "
                 "number\n"
                 "     }\n"
                 "     ,...\n"
                 "  ],\n"
                 "  \"vout\" : [             (array of json objects)\n"
                 "     {\n"
                 "       \"value\" : x.xxx,            (numeric) The value in " +
                 CURRENCY_UNIT +
                 "\n"
                 "       \"n\" : n,                    (numeric) index\n"
                 "       \"scriptPubKey\" : {          (json object)\n"
                 "         \"asm\" : \"asm\",          (string) the asm\n"
                 "         \"hex\" : \"hex\",          (string) the hex\n"
                 "         \"reqSigs\" : n,            (numeric) The required "
                 "sigs\n"
                 "         \"type\" : \"pubkeyhash\",  (string) The type, eg "
                 "'pubkeyhash'\n"
                 "         \"addresses\" : [           (json array of string)\n"
                 "           \"12tvKAXCxZjSmdNbao16dKXC8tRWfcF5oc\"   (string) "
                 "bitcoin address\n"
                 "           ,...\n"
                 "         ]\n"
                 "       }\n"
                 "     }\n"
                 "     ,...\n"
                 "  ],\n"
                 "}\n"},
             RPCExamples{
                 HelpExampleCli("decoderawtransaction", "\"hexstring\"") +
                 HelpExampleRpc("decoderawtransaction", "\"hexstring\"")},
         }
                                      .ToString());
     }
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     CMutableTransaction mtx;
 
     if (!DecodeHexTx(mtx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
 
     UniValue result(UniValue::VOBJ);
     TxToUniv(CTransaction(std::move(mtx)), uint256(), result, false);
 
     return result;
 }
 
 static UniValue decodescript(const Config &config,
                              const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "decodescript",
             "\nDecode a hex-encoded script.\n",
             {
                 {"hexstring", RPCArg::Type::STR_HEX, /* opt */ false,
                  /* default_val */ "", "the hex-encoded script"},
             },
             RPCResult{"{\n"
                       "  \"asm\":\"asm\",   (string) Script public key\n"
                       "  \"hex\":\"hex\",   (string) hex-encoded public key\n"
                       "  \"type\":\"type\", (string) The output type\n"
                       "  \"reqSigs\": n,    (numeric) The required signatures\n"
                       "  \"addresses\": [   (json array of string)\n"
                       "     \"address\"     (string) bitcoin address\n"
                       "     ,...\n"
                       "  ],\n"
                       "  \"p2sh\",\"address\" (string) address of P2SH script "
                       "wrapping this redeem script (not returned if the script "
                       "is already a P2SH).\n"
                       "}\n"},
             RPCExamples{HelpExampleCli("decodescript", "\"hexstring\"") +
                         HelpExampleRpc("decodescript", "\"hexstring\"")},
         }
                                      .ToString());
     }
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     UniValue r(UniValue::VOBJ);
     CScript script;
     if (request.params[0].get_str().size() > 0) {
         std::vector<uint8_t> scriptData(
             ParseHexV(request.params[0], "argument"));
         script = CScript(scriptData.begin(), scriptData.end());
     } else {
         // Empty scripts are valid.
     }
 
     ScriptPubKeyToUniv(script, r, false);
 
     UniValue type;
     type = find_value(r, "type");
 
     if (type.isStr() && type.get_str() != "scripthash") {
         // P2SH cannot be wrapped in a P2SH. If this script is already a P2SH,
         // don't return the address for a P2SH of the P2SH.
         r.pushKV("p2sh", EncodeDestination(CScriptID(script), config));
     }
 
     return r;
 }
 
 static UniValue combinerawtransaction(const Config &config,
                                       const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "combinerawtransaction",
             "\nCombine multiple partially signed transactions into one "
             "transaction.\n"
             "The combined transaction may be another partially signed "
             "transaction or a \n"
             "fully signed transaction.",
             {
                 {
                     "txs",
                     RPCArg::Type::ARR,
                     /* opt */ false,
                     /* default_val */ "",
                     "A json array of hex strings of partially signed "
                     "transactions",
                     {
                         {"hexstring", RPCArg::Type::STR_HEX,
                          /* opt */ false, /* default_val */ "",
                          "A transaction hash"},
                     },
                 },
             },
             RPCResult{"\"hex\"            (string) The hex-encoded raw "
                       "transaction with signature(s)\n"},
             RPCExamples{HelpExampleCli("combinerawtransaction",
                                        "[\"myhex1\", \"myhex2\", \"myhex3\"]")},
         }
                                      .ToString());
     }
 
     UniValue txs = request.params[0].get_array();
     std::vector<CMutableTransaction> txVariants(txs.size());
 
     for (unsigned int idx = 0; idx < txs.size(); idx++) {
         if (!DecodeHexTx(txVariants[idx], txs[idx].get_str())) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                strprintf("TX decode failed for tx %d", idx));
         }
     }
 
     if (txVariants.empty()) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Missing transactions");
     }
 
     // mergedTx will end up with all the signatures; it
     // starts as a clone of the rawtx:
     CMutableTransaction mergedTx(txVariants[0]);
 
     // Fetch previous transactions (inputs):
     CCoinsView viewDummy;
     CCoinsViewCache view(&viewDummy);
     {
         LOCK(cs_main);
         LOCK(g_mempool.cs);
         CCoinsViewCache &viewChain = *pcoinsTip;
         CCoinsViewMemPool viewMempool(&viewChain, g_mempool);
         // temporarily switch cache backend to db+mempool view
         view.SetBackend(viewMempool);
 
         for (const CTxIn &txin : mergedTx.vin) {
             // Load entries from viewChain into view; can fail.
             view.AccessCoin(txin.prevout);
         }
 
         // switch back to avoid locking mempool for too long
         view.SetBackend(viewDummy);
     }
 
     // Use CTransaction for the constant parts of the
     // transaction to avoid rehashing.
     const CTransaction txConst(mergedTx);
     // Sign what we can:
     for (size_t i = 0; i < mergedTx.vin.size(); i++) {
         CTxIn &txin = mergedTx.vin[i];
         const Coin &coin = view.AccessCoin(txin.prevout);
         if (coin.IsSpent()) {
             throw JSONRPCError(RPC_VERIFY_ERROR,
                                "Input not found or already spent");
         }
         SignatureData sigdata;
 
         const CTxOut &txout = coin.GetTxOut();
 
         // ... and merge in other signatures:
         for (const CMutableTransaction &txv : txVariants) {
             if (txv.vin.size() > i) {
                 sigdata.MergeSignatureData(DataFromTransaction(txv, i, txout));
             }
         }
         ProduceSignature(
             DUMMY_SIGNING_PROVIDER,
             MutableTransactionSignatureCreator(&mergedTx, i, txout.nValue),
             txout.scriptPubKey, sigdata);
 
         UpdateInput(txin, sigdata);
     }
 
     return EncodeHexTx(CTransaction(mergedTx));
 }
 
 static UniValue signrawtransactionwithkey(const Config &config,
                                           const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 4) {
         throw std::runtime_error(RPCHelpMan{
             "signrawtransactionwithkey",
             "\nSign inputs for raw transaction (serialized, hex-encoded).\n"
             "The second argument is an array of base58-encoded private\n"
             "keys that will be the only keys used to sign the transaction.\n"
             "The third optional argument (may be null) is an array of previous "
             "transaction outputs that\n"
             "this transaction depends on but may not yet be in the block "
             "chain.\n",
             {
                 {"hexstring", RPCArg::Type::STR_HEX, /* opt */ false,
                  /* default_val */ "", "The transaction hex string"},
                 {
                     "privkeys",
                     RPCArg::Type::ARR,
                     /* opt */ false,
                     /* default_val */ "",
                     "A json array of base58-encoded private keys for signing",
                     {
                         {"privatekey", RPCArg::Type::STR,
                          /* opt */ false, /* default_val */ "",
                          "private key in base58-encoding"},
                     },
                 },
                 {
                     "prevtxs",
                     RPCArg::Type::ARR,
                     /* opt */ true,
                     /* default_val */ "",
                     "A json array of previous dependent transaction outputs",
                     {
                         {
                             "",
                             RPCArg::Type::OBJ,
                             /* opt */ true,
                             /* default_val */ "",
                             "",
                             {
                                 {"txid", RPCArg::Type::STR_HEX,
                                  /* opt */ false, /* default_val */ "",
                                  "The transaction id"},
                                 {"vout", RPCArg::Type::NUM, /* opt */ false,
                                  /* default_val */ "", "The output number"},
                                 {"scriptPubKey", RPCArg::Type::STR_HEX,
                                  /* opt */ false, /* default_val */ "",
                                  "script key"},
                                 {"redeemScript", RPCArg::Type::STR_HEX,
                                  /* opt */ true, /* default_val */ "",
                                  "(required for P2SH) redeem script"},
                                 {"amount", RPCArg::Type::AMOUNT,
                                  /* opt */ false, /* default_val */ "",
                                  "The amount spent"},
                             },
                         },
                     },
                 },
                 {"sighashtype", RPCArg::Type::STR, /* opt */ true,
                  /* default_val */ "ALL|FORKID",
                  "The signature hash type. Must be one of:\n"
                  "       \"ALL|FORKID\"\n"
                  "       \"NONE|FORKID\"\n"
                  "       \"SINGLE|FORKID\"\n"
                  "       \"ALL|FORKID|ANYONECANPAY\"\n"
                  "       \"NONE|FORKID|ANYONECANPAY\"\n"
                  "       \"SINGLE|FORKID|ANYONECANPAY\""},
             },
             RPCResult{"{\n"
                       "  \"hex\" : \"value\",                  (string) The "
                       "hex-encoded raw transaction with signature(s)\n"
                       "  \"complete\" : true|false,          (boolean) If the "
                       "transaction has a complete set of signatures\n"
                       "  \"errors\" : [                      (json array of "
                       "objects) Script verification errors (if there are any)\n"
                       "    {\n"
                       "      \"txid\" : \"hash\",              (string) The "
                       "hash of the referenced, previous transaction\n"
                       "      \"vout\" : n,                   (numeric) The "
                       "index of the output to spent and used as input\n"
                       "      \"scriptSig\" : \"hex\",          (string) The "
                       "hex-encoded signature script\n"
                       "      \"sequence\" : n,               (numeric) Script "
                       "sequence number\n"
                       "      \"error\" : \"text\"              (string) "
                       "Verification or signing error related to the input\n"
                       "    }\n"
                       "    ,...\n"
                       "  ]\n"
                       "}\n"},
             RPCExamples{
                 HelpExampleCli("signrawtransactionwithkey", "\"myhex\"") +
                 HelpExampleRpc("signrawtransactionwithkey", "\"myhex\"")},
         }
                                      .ToString());
     }
 
     RPCTypeCheck(
         request.params,
         {UniValue::VSTR, UniValue::VARR, UniValue::VARR, UniValue::VSTR}, true);
 
     CMutableTransaction mtx;
     if (!DecodeHexTx(mtx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
 
     CBasicKeyStore keystore;
     const UniValue &keys = request.params[1].get_array();
     for (size_t idx = 0; idx < keys.size(); ++idx) {
         UniValue k = keys[idx];
         CKey key = DecodeSecret(k.get_str());
         if (!key.IsValid()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid private key");
         }
         keystore.AddKey(key);
     }
 
     return SignTransaction(*g_rpc_interfaces->chain, mtx, request.params[2],
                            &keystore, true, request.params[3]);
 }
 
 static UniValue sendrawtransaction(const Config &config,
                                    const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "sendrawtransaction",
             "\nSubmits raw transaction (serialized, hex-encoded) to local node "
             "and network.\n"
             "\nAlso see createrawtransaction and "
             "signrawtransactionwithkey calls.\n",
             {
                 {"hexstring", RPCArg::Type::STR_HEX, /* opt */ false,
                  /* default_val */ "", "The hex string of the raw transaction"},
                 {"allowhighfees", RPCArg::Type::BOOL, /* opt */ true,
                  /* default_val */ "false", "Allow high fees"},
             },
             RPCResult{
                 "\"hex\"             (string) The transaction hash in hex\n"},
             RPCExamples{
                 "\nCreate a transaction\n" +
                 HelpExampleCli(
                     "createrawtransaction",
                     "\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" "
                     "\"{\\\"myaddress\\\":0.01}\"") +
                 "Sign the transaction, and get back the hex\n" +
                 HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"") +
                 "\nSend the transaction (signed hex)\n" +
                 HelpExampleCli("sendrawtransaction", "\"signedhex\"") +
                 "\nAs a JSON-RPC call\n" +
                 HelpExampleRpc("sendrawtransaction", "\"signedhex\"")},
         }
                                      .ToString());
     }
 
     RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VBOOL});
 
     // parse hex string from parameter
     CMutableTransaction mtx;
     if (!DecodeHexTx(mtx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
 
     CTransactionRef tx(MakeTransactionRef(std::move(mtx)));
 
     bool allowhighfees = false;
     if (!request.params[1].isNull()) {
         allowhighfees = request.params[1].get_bool();
     }
     const Amount highfee{allowhighfees ? Amount::zero() : ::maxTxFee};
     TxId txid;
     std::string err_string;
     const TransactionError err =
         BroadcastTransaction(config, tx, txid, err_string, highfee);
     if (err != TransactionError::OK) {
         throw JSONRPCTransactionError(err, err_string);
     }
 
     return txid.GetHex();
 }
 
 static UniValue testmempoolaccept(const Config &config,
                                   const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "testmempoolaccept",
             "\nReturns if raw transaction (serialized, hex-encoded) would be "
             "accepted by mempool.\n"
             "\nThis checks if the transaction violates the consensus or policy "
             "rules.\n"
             "\nSee sendrawtransaction call.\n",
             {
                 {
                     "rawtxs",
                     RPCArg::Type::ARR,
                     /* opt */ false,
                     /* default_val */ "",
                     "An array of hex strings of raw transactions.\n"
                     "                                        Length must be "
                     "one for now.",
                     {
                         {"rawtx", RPCArg::Type::STR_HEX,
                          /* opt */ false, /* default_val */ "", ""},
                     },
                 },
                 {"allowhighfees", RPCArg::Type::BOOL, /* opt */ true,
                  /* default_val */ "false", "Allow high fees"},
             },
             RPCResult{
                 "[                   (array) The result of the mempool "
                 "acceptance test for each raw transaction in the input array.\n"
                 "                            Length is exactly one for now.\n"
                 " {\n"
                 "  \"txid\"           (string) The transaction hash in hex\n"
                 "  \"allowed\"        (boolean) If the mempool allows this tx "
                 "to be inserted\n"
                 "  \"reject-reason\"  (string) Rejection string (only present "
                 "when 'allowed' is false)\n"
                 " }\n"
                 "]\n"},
             RPCExamples{
                 "\nCreate a transaction\n" +
                 HelpExampleCli(
                     "createrawtransaction",
                     "\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" "
                     "\"{\\\"myaddress\\\":0.01}\"") +
                 "Sign the transaction, and get back the hex\n" +
                 HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"") +
                 "\nTest acceptance of the transaction (signed hex)\n" +
                 HelpExampleCli("testmempoolaccept", "[\"signedhex\"]") +
                 "\nAs a JSON-RPC call\n" +
                 HelpExampleRpc("testmempoolaccept", "[\"signedhex\"]")},
         }
                                      .ToString());
     }
 
     RPCTypeCheck(request.params, {UniValue::VARR, UniValue::VBOOL});
     if (request.params[0].get_array().size() != 1) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             "Array must contain exactly one raw transaction for now");
     }
 
     CMutableTransaction mtx;
     if (!DecodeHexTx(mtx, request.params[0].get_array()[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
     CTransactionRef tx(MakeTransactionRef(std::move(mtx)));
     const uint256 &txid = tx->GetId();
 
     Amount max_raw_tx_fee = maxTxFee;
     if (!request.params[1].isNull() && request.params[1].get_bool()) {
         max_raw_tx_fee = Amount::zero();
     }
 
     UniValue result(UniValue::VARR);
     UniValue result_0(UniValue::VOBJ);
     result_0.pushKV("txid", txid.GetHex());
 
     CValidationState state;
     bool missing_inputs;
     bool test_accept_res;
     {
         LOCK(cs_main);
         test_accept_res = AcceptToMemoryPool(
             config, g_mempool, state, std::move(tx), &missing_inputs,
             false /* bypass_limits */, max_raw_tx_fee, true /* test_accept */);
     }
     result_0.pushKV("allowed", test_accept_res);
     if (!test_accept_res) {
         if (state.IsInvalid()) {
             result_0.pushKV("reject-reason",
                             strprintf("%i: %s", state.GetRejectCode(),
                                       state.GetRejectReason()));
         } else if (missing_inputs) {
             result_0.pushKV("reject-reason", "missing-inputs");
         } else {
             result_0.pushKV("reject-reason", state.GetRejectReason());
         }
     }
 
     result.push_back(std::move(result_0));
     return result;
 }
 
 static std::string WriteHDKeypath(std::vector<uint32_t> &keypath) {
     std::string keypath_str = "m";
     for (uint32_t num : keypath) {
         keypath_str += "/";
         bool hardened = false;
         if (num & 0x80000000) {
             hardened = true;
             num &= ~0x80000000;
         }
 
         keypath_str += std::to_string(num);
         if (hardened) {
             keypath_str += "'";
         }
     }
     return keypath_str;
 }
 
 static UniValue decodepsbt(const Config &config,
                            const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "decodepsbt",
             "\nReturn a JSON object representing the serialized, "
             "base64-encoded partially signed Bitcoin transaction.\n",
             {
                 {"psbt", RPCArg::Type::STR, /* opt */ false,
                  /* default_val */ "", "The PSBT base64 string"},
             },
             RPCResult{
                 "{\n"
                 "  \"tx\" : {                   (json object) The decoded "
                 "network-serialized unsigned transaction.\n"
                 "    ...                                      The layout is "
                 "the same as the output of decoderawtransaction.\n"
                 "  },\n"
                 "  \"unknown\" : {                (json object) The unknown "
                 "global fields\n"
                 "    \"key\" : \"value\"            (key-value pair) An "
                 "unknown key-value pair\n"
                 "     ...\n"
                 "  },\n"
                 "  \"inputs\" : [                 (array of json objects)\n"
                 "    {\n"
                 "      \"utxo\" : {            (json object, optional) "
                 "Transaction output for UTXOs\n"
                 "        \"amount\" : x.xxx,           (numeric) The value "
                 "in " +
                 CURRENCY_UNIT +
                 "\n"
                 "        \"scriptPubKey\" : {          (json object)\n"
                 "          \"asm\" : \"asm\",            (string) The asm\n"
                 "          \"hex\" : \"hex\",            (string) The hex\n"
                 "          \"type\" : \"pubkeyhash\",    (string) The type, eg "
                 "'pubkeyhash'\n"
                 "          \"address\" : \"address\"     (string) Bitcoin "
                 "address if there is one\n"
                 "        }\n"
                 "      },\n"
                 "      \"partial_signatures\" : {             (json object, "
                 "optional)\n"
                 "        \"pubkey\" : \"signature\",           (string) The "
                 "public key and signature that corresponds to it.\n"
                 "        ,...\n"
                 "      }\n"
                 "      \"sighash\" : \"type\",                  (string, "
                 "optional) The sighash type to be used\n"
                 "      \"redeem_script\" : {       (json object, optional)\n"
                 "          \"asm\" : \"asm\",            (string) The asm\n"
                 "          \"hex\" : \"hex\",            (string) The hex\n"
                 "          \"type\" : \"pubkeyhash\",    (string) The type, eg "
                 "'pubkeyhash'\n"
                 "        }\n"
                 "      \"bip32_derivs\" : {          (json object, optional)\n"
                 "        \"pubkey\" : {                     (json object, "
                 "optional) The public key with the derivation path as the "
                 "value.\n"
                 "          \"master_fingerprint\" : \"fingerprint\"     "
                 "(string) The fingerprint of the master key\n"
                 "          \"path\" : \"path\",                         "
                 "(string) The path\n"
                 "        }\n"
                 "        ,...\n"
                 "      }\n"
                 "      \"final_scriptsig\" : {       (json object, optional)\n"
                 "          \"asm\" : \"asm\",            (string) The asm\n"
                 "          \"hex\" : \"hex\",            (string) The hex\n"
                 "        }\n"
                 "      \"unknown\" : {                (json object) The "
                 "unknown global fields\n"
                 "        \"key\" : \"value\"            (key-value pair) An "
                 "unknown key-value pair\n"
                 "         ...\n"
                 "      },\n"
                 "    }\n"
                 "    ,...\n"
                 "  ]\n"
                 "  \"outputs\" : [                 (array of json objects)\n"
                 "    {\n"
                 "      \"redeem_script\" : {       (json object, optional)\n"
                 "          \"asm\" : \"asm\",            (string) The asm\n"
                 "          \"hex\" : \"hex\",            (string) The hex\n"
                 "          \"type\" : \"pubkeyhash\",    (string) The type, eg "
                 "'pubkeyhash'\n"
                 "        }\n"
                 "      \"bip32_derivs\" : [          (array of json objects, "
                 "optional)\n"
                 "        {\n"
                 "          \"pubkey\" : \"pubkey\",                     "
                 "(string) The public key this path corresponds to\n"
                 "          \"master_fingerprint\" : \"fingerprint\"     "
                 "(string) The fingerprint of the master key\n"
                 "          \"path\" : \"path\",                         "
                 "(string) The path\n"
                 "          }\n"
                 "        }\n"
                 "        ,...\n"
                 "      ],\n"
                 "      \"unknown\" : {                (json object) The "
                 "unknown global fields\n"
                 "        \"key\" : \"value\"            (key-value pair) An "
                 "unknown key-value pair\n"
                 "         ...\n"
                 "      },\n"
                 "    }\n"
                 "    ,...\n"
                 "  ]\n"
                 "  \"fee\" : fee                      (numeric, optional) The "
                 "transaction fee paid if all UTXOs slots in the PSBT have been "
                 "filled.\n"
                 "}\n"},
             RPCExamples{HelpExampleCli("decodepsbt", "\"psbt\"")},
         }
                                      .ToString());
     }
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     // Unserialize the transactions
     PartiallySignedTransaction psbtx;
     std::string error;
     if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                            strprintf("TX decode failed %s", error));
     }
 
     UniValue result(UniValue::VOBJ);
 
     // Add the decoded tx
     UniValue tx_univ(UniValue::VOBJ);
     TxToUniv(CTransaction(*psbtx.tx), uint256(), tx_univ, false);
     result.pushKV("tx", tx_univ);
 
     // Unknown data
     if (psbtx.unknown.size() > 0) {
         UniValue unknowns(UniValue::VOBJ);
         for (auto entry : psbtx.unknown) {
             unknowns.pushKV(HexStr(entry.first), HexStr(entry.second));
         }
         result.pushKV("unknown", unknowns);
     }
 
     // inputs
     Amount total_in = Amount::zero();
     bool have_all_utxos = true;
     UniValue inputs(UniValue::VARR);
     for (size_t i = 0; i < psbtx.inputs.size(); ++i) {
         const PSBTInput &input = psbtx.inputs[i];
         UniValue in(UniValue::VOBJ);
         // UTXOs
         if (!input.utxo.IsNull()) {
             const CTxOut &txout = input.utxo;
 
             UniValue out(UniValue::VOBJ);
 
             out.pushKV("amount", ValueFromAmount(txout.nValue));
             total_in += txout.nValue;
 
             UniValue o(UniValue::VOBJ);
             ScriptToUniv(txout.scriptPubKey, o, true);
             out.pushKV("scriptPubKey", o);
             in.pushKV("utxo", out);
         } else {
             have_all_utxos = false;
         }
 
         // Partial sigs
         if (!input.partial_sigs.empty()) {
             UniValue partial_sigs(UniValue::VOBJ);
             for (const auto &sig : input.partial_sigs) {
                 partial_sigs.pushKV(HexStr(sig.second.first),
                                     HexStr(sig.second.second));
             }
             in.pushKV("partial_signatures", partial_sigs);
         }
 
         // Sighash
         uint8_t sighashbyte = input.sighash_type.getRawSigHashType() & 0xff;
         if (sighashbyte > 0) {
             in.pushKV("sighash", SighashToStr(sighashbyte));
         }
 
         // Redeem script
         if (!input.redeem_script.empty()) {
             UniValue r(UniValue::VOBJ);
             ScriptToUniv(input.redeem_script, r, false);
             in.pushKV("redeem_script", r);
         }
 
         // keypaths
         if (!input.hd_keypaths.empty()) {
             UniValue keypaths(UniValue::VARR);
             for (auto entry : input.hd_keypaths) {
                 UniValue keypath(UniValue::VOBJ);
                 keypath.pushKV("pubkey", HexStr(entry.first));
 
                 keypath.pushKV(
                     "master_fingerprint",
                     strprintf("%08x", ReadBE32(entry.second.fingerprint)));
                 keypath.pushKV("path", WriteHDKeypath(entry.second.path));
                 keypaths.push_back(keypath);
             }
             in.pushKV("bip32_derivs", keypaths);
         }
 
         // Final scriptSig
         if (!input.final_script_sig.empty()) {
             UniValue scriptsig(UniValue::VOBJ);
             scriptsig.pushKV("asm",
                              ScriptToAsmStr(input.final_script_sig, true));
             scriptsig.pushKV("hex", HexStr(input.final_script_sig));
             in.pushKV("final_scriptSig", scriptsig);
         }
 
         // Unknown data
         if (input.unknown.size() > 0) {
             UniValue unknowns(UniValue::VOBJ);
             for (auto entry : input.unknown) {
                 unknowns.pushKV(HexStr(entry.first), HexStr(entry.second));
             }
             in.pushKV("unknown", unknowns);
         }
 
         inputs.push_back(in);
     }
     result.pushKV("inputs", inputs);
 
     // outputs
     Amount output_value = Amount::zero();
     UniValue outputs(UniValue::VARR);
     for (size_t i = 0; i < psbtx.outputs.size(); ++i) {
         const PSBTOutput &output = psbtx.outputs[i];
         UniValue out(UniValue::VOBJ);
         // Redeem script
         if (!output.redeem_script.empty()) {
             UniValue r(UniValue::VOBJ);
             ScriptToUniv(output.redeem_script, r, false);
             out.pushKV("redeem_script", r);
         }
 
         // keypaths
         if (!output.hd_keypaths.empty()) {
             UniValue keypaths(UniValue::VARR);
             for (auto entry : output.hd_keypaths) {
                 UniValue keypath(UniValue::VOBJ);
                 keypath.pushKV("pubkey", HexStr(entry.first));
                 keypath.pushKV(
                     "master_fingerprint",
                     strprintf("%08x", ReadBE32(entry.second.fingerprint)));
                 keypath.pushKV("path", WriteHDKeypath(entry.second.path));
                 keypaths.push_back(keypath);
             }
             out.pushKV("bip32_derivs", keypaths);
         }
 
         // Unknown data
         if (output.unknown.size() > 0) {
             UniValue unknowns(UniValue::VOBJ);
             for (auto entry : output.unknown) {
                 unknowns.pushKV(HexStr(entry.first), HexStr(entry.second));
             }
             out.pushKV("unknown", unknowns);
         }
 
         outputs.push_back(out);
 
         // Fee calculation
         output_value += psbtx.tx->vout[i].nValue;
     }
     result.pushKV("outputs", outputs);
     if (have_all_utxos) {
         result.pushKV("fee", ValueFromAmount(total_in - output_value));
     }
 
     return result;
 }
 
 static UniValue combinepsbt(const Config &config,
                             const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "combinepsbt",
             "\nCombine multiple partially signed Bitcoin transactions into "
             "one transaction.\n"
             "Implements the Combiner role.\n",
             {
                 {
                     "txs",
                     RPCArg::Type::ARR,
                     /* opt */ false,
                     /* default_val */ "",
                     "A json array of base64 strings of partially signed "
                     "transactions",
                     {
                         {"psbt", RPCArg::Type::STR, /* opt */ false,
                          /* default_val */ "", "A base64 string of a PSBT"},
                     },
                 },
             },
             RPCResult{"  \"psbt\"          (string) The base64-encoded "
                       "partially signed transaction\n"},
             RPCExamples{HelpExampleCli(
                 "combinepsbt",
                 "[\"mybase64_1\", \"mybase64_2\", \"mybase64_3\"]")},
         }
                                      .ToString());
     }
 
     RPCTypeCheck(request.params, {UniValue::VARR}, true);
 
     // Unserialize the transactions
     std::vector<PartiallySignedTransaction> psbtxs;
     UniValue txs = request.params[0].get_array();
     for (size_t i = 0; i < txs.size(); ++i) {
         PartiallySignedTransaction psbtx;
         std::string error;
         if (!DecodeBase64PSBT(psbtx, txs[i].get_str(), error)) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                strprintf("TX decode failed %s", error));
         }
         psbtxs.push_back(psbtx);
     }
 
     PartiallySignedTransaction merged_psbt;
     const TransactionError error = CombinePSBTs(merged_psbt, psbtxs);
     if (error != TransactionError::OK) {
         throw JSONRPCTransactionError(error);
     }
 
     UniValue result(UniValue::VOBJ);
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << merged_psbt;
     return EncodeBase64((uint8_t *)ssTx.data(), ssTx.size());
 }
 
 static UniValue finalizepsbt(const Config &config,
                              const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "finalizepsbt",
             "Finalize the inputs of a PSBT. If the transaction is "
             "fully signed, it will produce a\n"
             "network serialized transaction which can be broadcast "
             "with sendrawtransaction. Otherwise a PSBT will be\n"
             "created which has the final_scriptSigfields filled for "
             "inputs that are complete.\n"
             "Implements the Finalizer and Extractor roles.\n",
             {
                 {"psbt", RPCArg::Type::STR, /* opt */ false,
                  /* default_val */ "", "A base64 string of a PSBT"},
                 {"extract", RPCArg::Type::BOOL, /* opt */ true,
                  /* default_val */ "true",
                  "If true and the transaction is complete,\n"
                  "                             extract and return the complete "
                  "transaction in normal network serialization instead of the "
                  "PSBT."},
             },
             RPCResult{
                 "{\n"
                 "  \"psbt\" : \"value\",          (string) The base64-encoded "
                 "partially signed transaction if not extracted\n"
                 "  \"hex\" : \"value\",           (string) The hex-encoded "
                 "network transaction if extracted\n"
                 "  \"complete\" : true|false,   (boolean) If the transaction "
                 "has a complete set of signatures\n"
                 "  ]\n"
                 "}\n"},
             RPCExamples{HelpExampleCli("finalizepsbt", "\"psbt\"")},
         }
                                      .ToString());
     }
 
     RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VBOOL}, true);
 
     // Unserialize the transactions
     PartiallySignedTransaction psbtx;
     std::string error;
     if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                            strprintf("TX decode failed %s", error));
     }
 
     bool extract = request.params[1].isNull() || (!request.params[1].isNull() &&
                                                   request.params[1].get_bool());
 
     CMutableTransaction mtx;
     bool complete = FinalizeAndExtractPSBT(psbtx, mtx);
 
     UniValue result(UniValue::VOBJ);
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     std::string result_str;
 
     if (complete && extract) {
         ssTx << mtx;
         result_str = HexStr(ssTx.str());
         result.pushKV("hex", result_str);
     } else {
         ssTx << psbtx;
         result_str = EncodeBase64(ssTx.str());
         result.pushKV("psbt", result_str);
     }
     result.pushKV("complete", complete);
 
     return result;
 }
 
 static UniValue createpsbt(const Config &config,
                            const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 3) {
         throw std::runtime_error(RPCHelpMan{
             "createpsbt",
             "\nCreates a transaction in the Partially Signed Transaction "
             "format.\n"
             "Implements the Creator role.\n",
             {
                 {
                     "inputs",
                     RPCArg::Type::ARR,
                     /* opt */ false,
                     /* default_val */ "",
                     "A json array of json objects",
                     {
                         {
                             "",
                             RPCArg::Type::OBJ,
                             /* opt */ false,
                             /* default_val */ "",
                             "",
                             {
                                 {"txid", RPCArg::Type::STR_HEX,
                                  /* opt */ false, /* default_val */ "",
                                  "The transaction id"},
                                 {"vout", RPCArg::Type::NUM, /* opt */ false,
                                  /* default_val */ "", "The output number"},
                                 {"sequence", RPCArg::Type::NUM,
                                  /* opt */ true, /* default_val */ "",
                                  "The sequence number"},
                             },
                         },
                     },
                 },
                 {
                     "outputs",
                     RPCArg::Type::ARR,
                     /* opt */ false,
                     /* default_val */ "",
                     "a json array with outputs (key-value pairs).\n"
                     "For compatibility reasons, a dictionary, which holds "
                     "the key-value pairs directly, is also\n"
                     "                             accepted as second "
                     "parameter.",
                     {
                         {
                             "",
                             RPCArg::Type::OBJ,
                             /* opt */ true,
                             /* default_val */ "",
                             "",
                             {
                                 {"address", RPCArg::Type::AMOUNT,
                                  /* opt */ false, /* default_val */ "",
                                  "A key-value pair. The key (string) is "
                                  "the bitcoin address, the value (float or "
                                  "string) is the amount in " +
                                      CURRENCY_UNIT},
                             },
                         },
                         {
                             "",
                             RPCArg::Type::OBJ,
                             /* opt */ true,
                             /* default_val */ "",
                             "",
                             {
                                 {"data", RPCArg::Type::STR_HEX,
                                  /* opt */ false, /* default_val */ "",
                                  "A key-value pair. The key must be "
                                  "\"data\", the value is hex-encoded data"},
                             },
                         },
                     },
                 },
                 {"locktime", RPCArg::Type::NUM, /* opt */ true,
                  /* default_val */ "0",
                  "Raw locktime. Non-0 value also locktime-activates inputs"},
             },
             RPCResult{"  \"psbt\"        (string)  The resulting raw "
                       "transaction (base64-encoded string)\n"},
             RPCExamples{HelpExampleCli(
                 "createpsbt", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                               "\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"")},
         }
                                      .ToString());
     }
 
     RPCTypeCheck(request.params,
                  {
                      UniValue::VARR,
                      UniValueType(), // ARR or OBJ, checked later
                      UniValue::VNUM,
                  },
                  true);
 
     CMutableTransaction rawTx =
         ConstructTransaction(config.GetChainParams(), request.params[0],
                              request.params[1], request.params[2]);
 
     // Make a blank psbt
     PartiallySignedTransaction psbtx;
     psbtx.tx = rawTx;
     for (size_t i = 0; i < rawTx.vin.size(); ++i) {
         psbtx.inputs.push_back(PSBTInput());
     }
     for (size_t i = 0; i < rawTx.vout.size(); ++i) {
         psbtx.outputs.push_back(PSBTOutput());
     }
 
     // Serialize the PSBT
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
 
     return EncodeBase64((uint8_t *)ssTx.data(), ssTx.size());
 }
 
 static UniValue converttopsbt(const Config &config,
                               const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "converttopsbt",
             "\nConverts a network serialized transaction to a PSBT. "
             "This should be used only with createrawtransaction and "
             "fundrawtransaction\n"
             "createpsbt and walletcreatefundedpsbt should be used for new "
             "applications.\n",
             {
                 {"hexstring", RPCArg::Type::STR_HEX, /* opt */ false,
                  /* default_val */ "", "The hex string of a raw transaction"},
                 {"permitsigdata", RPCArg::Type::BOOL, /* opt */ true,
                  /* default_val */ "false",
                  "If true, any signatures in the input will be discarded and "
                  "conversion.\n"
                  "                              will continue. If false, RPC "
                  "will fail if any signatures are present."},
             },
             RPCResult{"  \"psbt\"        (string)  The resulting raw "
                       "transaction (base64-encoded string)\n"},
             RPCExamples{
                 "\nCreate a transaction\n" +
                 HelpExampleCli("createrawtransaction",
                                "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                                "\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"") +
                 "\nConvert the transaction to a PSBT\n" +
                 HelpExampleCli("converttopsbt", "\"rawtransaction\"")},
         }
                                      .ToString());
     }
 
     RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VBOOL}, true);
 
     // parse hex string from parameter
     CMutableTransaction tx;
     bool permitsigdata =
         request.params[1].isNull() ? false : request.params[1].get_bool();
     if (!DecodeHexTx(tx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
 
     // Remove all scriptSigs from inputs
     for (CTxIn &input : tx.vin) {
         if (!input.scriptSig.empty() && !permitsigdata) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                "Inputs must not have scriptSigs");
         }
         input.scriptSig.clear();
     }
 
     // Make a blank psbt
     PartiallySignedTransaction psbtx;
     psbtx.tx = tx;
     for (size_t i = 0; i < tx.vin.size(); ++i) {
         psbtx.inputs.push_back(PSBTInput());
     }
     for (size_t i = 0; i < tx.vout.size(); ++i) {
         psbtx.outputs.push_back(PSBTOutput());
     }
 
     // Serialize the PSBT
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
 
     return EncodeBase64((uint8_t *)ssTx.data(), ssTx.size());
 }
 
 UniValue utxoupdatepsbt(const Config &config, const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "utxoupdatepsbt",
             "\nUpdates a PSBT with witness UTXOs retrieved from the UTXO set "
             "or the mempool.\n",
             {{"psbt", RPCArg::Type::STR,
               /* opt */ false, /* default_val */ "",
               "A base64 string of a PSBT"}},
             RPCResult{"  \"psbt\"          (string) The base64-encoded "
                       "partially signed transaction with inputs updated\n"},
             RPCExamples{HelpExampleCli("utxoupdatepsbt", "\"psbt\"")}}
                                      .ToString());
     }
 
     RPCTypeCheck(request.params, {UniValue::VSTR}, true);
 
     // Unserialize the transactions
     PartiallySignedTransaction psbtx;
     std::string error;
     if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                            strprintf("TX decode failed %s", error));
     }
 
     // Fetch previous transactions (inputs):
     CCoinsView viewDummy;
     CCoinsViewCache view(&viewDummy);
     {
         LOCK2(cs_main, g_mempool.cs);
         CCoinsViewCache &viewChain = *pcoinsTip;
         CCoinsViewMemPool viewMempool(&viewChain, g_mempool);
         // temporarily switch cache backend to db+mempool view
         view.SetBackend(viewMempool);
 
         for (const CTxIn &txin : psbtx.tx->vin) {
             // Load entries from viewChain into view; can fail.
             view.AccessCoin(txin.prevout);
         }
 
         // switch back to avoid locking mempool for too long
         view.SetBackend(viewDummy);
     }
 
     // Fill the inputs
     for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
         PSBTInput &input = psbtx.inputs.at(i);
 
         if (!input.utxo.IsNull()) {
             continue;
         }
 
         input.utxo = view.AccessCoin(psbtx.tx->vin[i].prevout).GetTxOut();
     }
 
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
     return EncodeBase64((uint8_t *)ssTx.data(), ssTx.size());
 }
 
 UniValue joinpsbts(const Config &config, const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "joinpsbts",
             "\nJoins multiple distinct PSBTs with different inputs and outputs "
             "into one PSBT with inputs and outputs from all of the PSBTs\n"
             "No input in any of the PSBTs can be in more than one of the "
             "PSBTs.\n",
             {{"txs",
               RPCArg::Type::ARR,
               /* opt */ false,
               /* default_val */ "",
               "A json array of base64 strings of partially signed transactions",
               {{"psbt", RPCArg::Type::STR, /* opt */ false,
                 /* default_val */ "", "A base64 string of a PSBT"}}}},
             RPCResult{"  \"psbt\"          (string) The base64-encoded "
                       "partially signed transaction\n"},
             RPCExamples{HelpExampleCli("joinpsbts", "\"psbt\"")}}
                                      .ToString());
     }
 
     RPCTypeCheck(request.params, {UniValue::VARR}, true);
 
     // Unserialize the transactions
     std::vector<PartiallySignedTransaction> psbtxs;
     UniValue txs = request.params[0].get_array();
 
     if (txs.size() <= 1) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "At least two PSBTs are required to join PSBTs.");
     }
 
     int32_t best_version = 1;
     uint32_t best_locktime = 0xffffffff;
     for (size_t i = 0; i < txs.size(); ++i) {
         PartiallySignedTransaction psbtx;
         std::string error;
         if (!DecodeBase64PSBT(psbtx, txs[i].get_str(), error)) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                strprintf("TX decode failed %s", error));
         }
         psbtxs.push_back(psbtx);
         // Choose the highest version number
         if (psbtx.tx->nVersion > best_version) {
             best_version = psbtx.tx->nVersion;
         }
         // Choose the lowest lock time
         if (psbtx.tx->nLockTime < best_locktime) {
             best_locktime = psbtx.tx->nLockTime;
         }
     }
 
     // Create a blank psbt where everything will be added
     PartiallySignedTransaction merged_psbt;
     merged_psbt.tx = CMutableTransaction();
     merged_psbt.tx->nVersion = best_version;
     merged_psbt.tx->nLockTime = best_locktime;
 
     // Merge
     for (auto &psbt : psbtxs) {
         for (size_t i = 0; i < psbt.tx->vin.size(); ++i) {
             if (!merged_psbt.AddInput(psbt.tx->vin[i], psbt.inputs[i])) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     strprintf(
                         "Input %s:%d exists in multiple PSBTs",
                         psbt.tx->vin[i].prevout.GetTxId().ToString().c_str(),
                         psbt.tx->vin[i].prevout.GetN()));
             }
         }
         for (size_t i = 0; i < psbt.tx->vout.size(); ++i) {
             merged_psbt.AddOutput(psbt.tx->vout[i], psbt.outputs[i]);
         }
         merged_psbt.unknown.insert(psbt.unknown.begin(), psbt.unknown.end());
     }
 
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << merged_psbt;
     return EncodeBase64((uint8_t *)ssTx.data(), ssTx.size());
 }
 
 UniValue analyzepsbt(const Config &config, const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "analyzepsbt",
             "\nAnalyzes and provides information about the current status of a "
             "PSBT and its inputs\n",
             {{"psbt", RPCArg::Type::STR, /* opt */ false, /* default_var */ "",
               "A base64 string of a PSBT"}},
             RPCResult{
                 "{\n"
                 "  \"inputs\" : [                      (array of json "
                 "objects)\n"
                 "    {\n"
                 "      \"has_utxo\" : true|false     (boolean) Whether a UTXO "
                 "is provided\n"
                 "      \"is_final\" : true|false     (boolean) Whether the "
                 "input is finalized\n"
                 "      \"missing\" : {               (json object, optional) "
                 "Things that are missing that are required to complete this "
                 "input\n"
                 "        \"pubkeys\" : [             (array)\n"
                 "          \"keyid\"                 (string) Public key ID, "
                 "hash160 of the public key, of a public key whose BIP 32 "
                 "derivation path is missing\n"
                 "        ]\n"
                 "        \"signatures\" : [          (array)\n"
                 "          \"keyid\"                 (string) Public key ID, "
                 "hash160 of the public key, of a public key whose signature is "
                 "missing\n"
                 "        ]\n"
                 "        \"redeemscript\" : \"hash\"   (string) Hash160 of the "
                 "redeemScript that is missing\n"
                 "      }\n"
                 "      \"next\" : \"role\"           (string) Role of the next "
                 "person that this input needs to go to\n"
                 "    }\n"
                 "    ,...\n"
                 "  ]\n"
                 "  \"estimated_vsize\" : vsize       (numeric) Estimated vsize "
                 "of the final signed transaction\n"
                 "  \"estimated_feerate\" : feerate   (numeric, optional) "
                 "Estimated feerate of the final signed transaction. Shown only "
                 "if all UTXO slots in the PSBT have been filled.\n"
                 "  \"fee\" : fee                     (numeric, optional) The "
                 "transaction fee paid. Shown only if all UTXO slots in the "
                 "PSBT have been filled.\n"
                 "  \"next\" : \"role\"                 (string) Role of the "
                 "next person that this psbt needs to go to\n"
                 "}\n"},
             RPCExamples{HelpExampleCli("analyzepsbt", "\"psbt\"")}}
                                      .ToString());
     }
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     // Unserialize the transaction
     PartiallySignedTransaction psbtx;
     std::string error;
     if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                            strprintf("TX decode failed %s", error));
     }
 
-    // Go through each input and build status
+    PSBTAnalysis psbta = AnalyzePSBT(psbtx);
+
     UniValue result(UniValue::VOBJ);
     UniValue inputs_result(UniValue::VARR);
-    bool calc_fee = true;
-    bool all_final = true;
-    bool only_missing_sigs = true;
-    bool only_missing_final = false;
-    Amount in_amt{Amount::zero()};
-    for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
-        PSBTInput &input = psbtx.inputs[i];
+    for (const auto &input : psbta.inputs) {
         UniValue input_univ(UniValue::VOBJ);
         UniValue missing(UniValue::VOBJ);
 
-        // Check for a UTXO
-        CTxOut utxo;
-        if (psbtx.GetInputUTXO(utxo, i)) {
-            in_amt += utxo.nValue;
-            input_univ.pushKV("has_utxo", true);
-        } else {
-            input_univ.pushKV("has_utxo", false);
-            input_univ.pushKV("is_final", false);
-            input_univ.pushKV("next", "updater");
-            calc_fee = false;
-        }
+        input_univ.pushKV("has_utxo", input.has_utxo);
+        input_univ.pushKV("is_final", input.is_final);
+        input_univ.pushKV("next", PSBTRoleName(input.next));
 
-        // Check if it is final
-        if (!utxo.IsNull() && !PSBTInputSigned(input)) {
-            input_univ.pushKV("is_final", false);
-            all_final = false;
-
-            // Figure out what is missing
-            SignatureData outdata;
-            bool complete = SignPSBTInput(DUMMY_SIGNING_PROVIDER, psbtx, i,
-                                          SigHashType().withForkId(), &outdata);
-
-            // Things are missing
-            if (!complete) {
-                if (!outdata.missing_pubkeys.empty()) {
-                    // Missing pubkeys
-                    UniValue missing_pubkeys_univ(UniValue::VARR);
-                    for (const CKeyID &pubkey : outdata.missing_pubkeys) {
-                        missing_pubkeys_univ.push_back(HexStr(pubkey));
-                    }
-                    missing.pushKV("pubkeys", missing_pubkeys_univ);
-                }
-                if (!outdata.missing_redeem_script.IsNull()) {
-                    // Missing redeemScript
-                    missing.pushKV("redeemscript",
-                                   HexStr(outdata.missing_redeem_script));
-                }
-                if (!outdata.missing_sigs.empty()) {
-                    // Missing sigs
-                    UniValue missing_sigs_univ(UniValue::VARR);
-                    for (const CKeyID &pubkey : outdata.missing_sigs) {
-                        missing_sigs_univ.push_back(HexStr(pubkey));
-                    }
-                    missing.pushKV("signatures", missing_sigs_univ);
-                }
-                input_univ.pushKV("missing", missing);
-
-                // If we are only missing signatures and nothing else, then next
-                // is signer
-                if (outdata.missing_pubkeys.empty() &&
-                    outdata.missing_redeem_script.IsNull() &&
-                    !outdata.missing_sigs.empty()) {
-                    input_univ.pushKV("next", "signer");
-                } else {
-                    only_missing_sigs = false;
-                    input_univ.pushKV("next", "updater");
-                }
-            } else {
-                only_missing_final = true;
-                input_univ.pushKV("next", "finalizer");
+        if (!input.missing_pubkeys.empty()) {
+            UniValue missing_pubkeys_univ(UniValue::VARR);
+            for (const CKeyID &pubkey : input.missing_pubkeys) {
+                missing_pubkeys_univ.push_back(HexStr(pubkey));
             }
-        } else if (!utxo.IsNull()) {
-            input_univ.pushKV("is_final", true);
+            missing.pushKV("pubkeys", missing_pubkeys_univ);
+        }
+        if (!input.missing_redeem_script.IsNull()) {
+            missing.pushKV("redeemscript", HexStr(input.missing_redeem_script));
+        }
+        if (!input.missing_sigs.empty()) {
+            UniValue missing_sigs_univ(UniValue::VARR);
+            for (const CKeyID &pubkey : input.missing_sigs) {
+                missing_sigs_univ.push_back(HexStr(pubkey));
+            }
+            missing.pushKV("signatures", missing_sigs_univ);
+        }
+        if (!missing.getKeys().empty()) {
+            input_univ.pushKV("missing", missing);
         }
         inputs_result.push_back(input_univ);
     }
     result.pushKV("inputs", inputs_result);
 
-    if (all_final) {
-        only_missing_sigs = false;
-        result.pushKV("next", "extractor");
-    }
-    if (calc_fee) {
-        // Get the output amount
-        Amount out_amt = std::accumulate(
-            psbtx.tx->vout.begin(), psbtx.tx->vout.end(), Amount::zero(),
-            [](Amount a, const CTxOut &b) { return a += b.nValue; });
-
-        // Get the fee
-        Amount fee = in_amt - out_amt;
-
-        // Estimate the size
-        CMutableTransaction mtx(*psbtx.tx);
-        CCoinsView view_dummy;
-        CCoinsViewCache view(&view_dummy);
-        bool success = true;
-
-        for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
-            PSBTInput &input = psbtx.inputs[i];
-            if (SignPSBTInput(DUMMY_SIGNING_PROVIDER, psbtx, i,
-                              SigHashType().withForkId(), nullptr, true)) {
-                mtx.vin[i].scriptSig = input.final_script_sig;
-
-                CTxOut newUtxo;
-                if (!psbtx.GetInputUTXO(newUtxo, i)) {
-                    success = false;
-                    break;
-                }
-                view.AddCoin(psbtx.tx->vin[i].prevout, Coin(newUtxo, 1, false),
-                             true);
-            } else {
-                success = false;
-                break;
-            }
-        }
-
-        if (success) {
-            CTransaction ctx = CTransaction(mtx);
-            size_t size = ctx.GetTotalSize();
-            result.pushKV("estimated_vsize", uint64_t(size));
-            // Estimate fee rate
-            CFeeRate feerate(fee, size);
-            result.pushKV("estimated_feerate", feerate.ToString());
-        }
-        result.pushKV("fee", ValueFromAmount(fee));
-
-        if (only_missing_sigs) {
-            result.pushKV("next", "signer");
-        } else if (only_missing_final) {
-            result.pushKV("next", "finalizer");
-        } else if (all_final) {
-            result.pushKV("next", "extractor");
-        } else {
-            result.pushKV("next", "updater");
-        }
-    } else {
-        result.pushKV("next", "updater");
+    if (psbta.estimated_vsize != nullopt) {
+        result.pushKV("estimated_vsize", (int)*psbta.estimated_vsize);
+    }
+    if (psbta.estimated_feerate != nullopt) {
+        result.pushKV("estimated_feerate",
+                      ValueFromAmount(psbta.estimated_feerate->GetFeePerK()));
     }
+    if (psbta.fee != nullopt) {
+        result.pushKV("fee", ValueFromAmount(*psbta.fee));
+    }
+    result.pushKV("next", PSBTRoleName(psbta.next));
+
     return result;
 }
 
 // clang-format off
 static const CRPCCommand commands[] = {
     //  category            name                         actor (function)           argNames
     //  ------------------- ------------------------     ----------------------     ----------
     { "rawtransactions",    "getrawtransaction",         getrawtransaction,         {"txid","verbose","blockhash"} },
     { "rawtransactions",    "createrawtransaction",      createrawtransaction,      {"inputs","outputs","locktime"} },
     { "rawtransactions",    "decoderawtransaction",      decoderawtransaction,      {"hexstring"} },
     { "rawtransactions",    "decodescript",              decodescript,              {"hexstring"} },
     { "rawtransactions",    "sendrawtransaction",        sendrawtransaction,        {"hexstring","allowhighfees"} },
     { "rawtransactions",    "combinerawtransaction",     combinerawtransaction,     {"txs"} },
     { "rawtransactions",    "signrawtransactionwithkey", signrawtransactionwithkey, {"hexstring","privkeys","prevtxs","sighashtype"} },
     { "rawtransactions",    "testmempoolaccept",         testmempoolaccept,         {"rawtxs","allowhighfees"} },
     { "rawtransactions",    "decodepsbt",                decodepsbt,                {"psbt"} },
     { "rawtransactions",    "combinepsbt",               combinepsbt,               {"txs"} },
     { "rawtransactions",    "finalizepsbt",              finalizepsbt,              {"psbt", "extract"} },
     { "rawtransactions",    "createpsbt",                createpsbt,                {"inputs","outputs","locktime"} },
     { "rawtransactions",    "converttopsbt",             converttopsbt,             {"hexstring","permitsigdata"} },
     { "rawtransactions",    "utxoupdatepsbt",            utxoupdatepsbt,            {"psbt"} },
     { "rawtransactions",    "joinpsbts",                 joinpsbts,                 {"txs"} },
     { "rawtransactions",    "analyzepsbt",               analyzepsbt,               {"psbt"} },
     { "blockchain",         "gettxoutproof",             gettxoutproof,             {"txids", "blockhash"} },
     { "blockchain",         "verifytxoutproof",          verifytxoutproof,          {"proof"} },
 };
 // clang-format on
 
 void RegisterRawTransactionRPCCommands(CRPCTable &t) {
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
     }
 }
diff --git a/test/functional/rpc_psbt.py b/test/functional/rpc_psbt.py
index 313ff4561d..d70e4e128d 100755
--- a/test/functional/rpc_psbt.py
+++ b/test/functional/rpc_psbt.py
@@ -1,311 +1,311 @@
 #!/usr/bin/env python3
 # Copyright (c) 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.
 """Test the Partially Signed Transaction RPCs.
 """
 
 import json
 import os
 
 from decimal import Decimal
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_raises_rpc_error,
     find_output,
 )
 
 # Create one-input, one-output, no-fee transaction:
 
 
 class PSBTTest(BitcoinTestFramework):
 
     def set_test_params(self):
         self.setup_clean_chain = False
         self.num_nodes = 3
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def run_test(self):
         # Create and fund a raw tx for sending 10 BTC
         psbtx1 = self.nodes[0].walletcreatefundedpsbt(
             [], {self.nodes[2].getnewaddress(): 10})['psbt']
 
         # Node 1 should not be able to add anything to it but still return the
         # psbtx same as before
         psbtx = self.nodes[1].walletprocesspsbt(psbtx1)['psbt']
         assert_equal(psbtx1, psbtx)
 
         # Sign the transaction and send
         signed_tx = self.nodes[0].walletprocesspsbt(psbtx)['psbt']
         final_tx = self.nodes[0].finalizepsbt(signed_tx)['hex']
         self.nodes[0].sendrawtransaction(final_tx)
 
         # Create p2sh, p2pkh addresses
         pubkey0 = self.nodes[0].getaddressinfo(
             self.nodes[0].getnewaddress())['pubkey']
         pubkey1 = self.nodes[1].getaddressinfo(
             self.nodes[1].getnewaddress())['pubkey']
         pubkey2 = self.nodes[2].getaddressinfo(
             self.nodes[2].getnewaddress())['pubkey']
         p2sh = self.nodes[1].addmultisigaddress(
             2, [pubkey0, pubkey1, pubkey2], "")['address']
         p2pkh = self.nodes[1].getnewaddress("")
 
         # fund those addresses
         rawtx = self.nodes[0].createrawtransaction([], {p2sh: 10, p2pkh: 10})
         rawtx = self.nodes[0].fundrawtransaction(rawtx, {"changePosition": 0})
         signed_tx = self.nodes[0].signrawtransactionwithwallet(rawtx['hex'])[
             'hex']
         txid = self.nodes[0].sendrawtransaction(signed_tx)
         self.nodes[0].generate(6)
         self.sync_all()
 
         # Find the output pos
         p2sh_pos = -1
         p2pkh_pos = -1
         decoded = self.nodes[0].decoderawtransaction(signed_tx)
         for out in decoded['vout']:
             if out['scriptPubKey']['addresses'][0] == p2sh:
                 p2sh_pos = out['n']
             elif out['scriptPubKey']['addresses'][0] == p2pkh:
                 p2pkh_pos = out['n']
 
         # spend single key from node 1
         rawtx = self.nodes[1].walletcreatefundedpsbt([{"txid": txid, "vout": p2pkh_pos}], {
                                                      self.nodes[1].getnewaddress(): 9.99})['psbt']
         walletprocesspsbt_out = self.nodes[1].walletprocesspsbt(rawtx)
         assert_equal(walletprocesspsbt_out['complete'], True)
         self.nodes[1].sendrawtransaction(
             self.nodes[1].finalizepsbt(walletprocesspsbt_out['psbt'])['hex'])
 
         # partially sign multisig things with node 1
         psbtx = self.nodes[1].walletcreatefundedpsbt([{"txid": txid, "vout": p2sh_pos}], {
                                                      self.nodes[1].getnewaddress(): 9.99})['psbt']
         walletprocesspsbt_out = self.nodes[1].walletprocesspsbt(psbtx)
         psbtx = walletprocesspsbt_out['psbt']
         assert_equal(walletprocesspsbt_out['complete'], False)
 
         # partially sign with node 2. This should be complete and sendable
         walletprocesspsbt_out = self.nodes[2].walletprocesspsbt(psbtx)
         assert_equal(walletprocesspsbt_out['complete'], True)
         self.nodes[2].sendrawtransaction(
             self.nodes[2].finalizepsbt(walletprocesspsbt_out['psbt'])['hex'])
 
         # check that walletprocesspsbt fails to decode a non-psbt
         rawtx = self.nodes[1].createrawtransaction([{"txid": txid, "vout": p2pkh_pos}], {
                                                    self.nodes[1].getnewaddress(): 9.99})
         assert_raises_rpc_error(-22, "TX decode failed",
                                 self.nodes[1].walletprocesspsbt, rawtx)
 
         # Convert a non-psbt to psbt and make sure we can decode it
         rawtx = self.nodes[0].createrawtransaction(
             [], {self.nodes[1].getnewaddress(): 10})
         rawtx = self.nodes[0].fundrawtransaction(rawtx)
         new_psbt = self.nodes[0].converttopsbt(rawtx['hex'])
         self.nodes[0].decodepsbt(new_psbt)
 
         # Make sure that a psbt with signatures cannot be converted
         signedtx = self.nodes[0].signrawtransactionwithwallet(rawtx['hex'])
         assert_raises_rpc_error(-22, "Inputs must not have scriptSigs",
                                 self.nodes[0].converttopsbt, signedtx['hex'])
         # Unless we allow it to convert and strip signatures
         self.nodes[0].converttopsbt(signedtx['hex'], True)
 
         # Explicilty allow converting non-empty txs
         new_psbt = self.nodes[0].converttopsbt(rawtx['hex'])
         self.nodes[0].decodepsbt(new_psbt)
 
         # Create outputs to nodes 1 and 2
         node1_addr = self.nodes[1].getnewaddress()
         node2_addr = self.nodes[2].getnewaddress()
         txid1 = self.nodes[0].sendtoaddress(node1_addr, 13)
         txid2 = self.nodes[0].sendtoaddress(node2_addr, 13)
         blockhash = self.nodes[0].generate(6)[0]
         self.sync_all()
         vout1 = find_output(self.nodes[1], txid1, 13, blockhash=blockhash)
         vout2 = find_output(self.nodes[2], txid2, 13, blockhash=blockhash)
 
         # Create a psbt spending outputs from nodes 1 and 2
         psbt_orig = self.nodes[0].createpsbt([{"txid": txid1, "vout": vout1}, {
                                              "txid": txid2, "vout": vout2}], {self.nodes[0].getnewaddress(): 25.999})
 
         # Update psbts, should only have data for one input and not the other
         psbt1 = self.nodes[1].walletprocesspsbt(psbt_orig)['psbt']
         psbt1_decoded = self.nodes[0].decodepsbt(psbt1)
         assert psbt1_decoded['inputs'][0] and not psbt1_decoded['inputs'][1]
         psbt2 = self.nodes[2].walletprocesspsbt(psbt_orig)['psbt']
         psbt2_decoded = self.nodes[0].decodepsbt(psbt2)
         assert not psbt2_decoded['inputs'][0] and psbt2_decoded['inputs'][1]
 
         # Combine, finalize, and send the psbts
         combined = self.nodes[0].combinepsbt([psbt1, psbt2])
         finalized = self.nodes[0].finalizepsbt(combined)['hex']
         self.nodes[0].sendrawtransaction(finalized)
         self.nodes[0].generate(6)
         self.sync_all()
 
         unspent = self.nodes[0].listunspent()[0]
 
         # Regression test for 14473 (mishandling of already-signed
         # transaction):
         psbtx_info = self.nodes[0].walletcreatefundedpsbt([{"txid": unspent["txid"], "vout":unspent["vout"]}], [
                                                           {self.nodes[2].getnewaddress():unspent["amount"] + 1}])
         complete_psbt = self.nodes[0].walletprocesspsbt(psbtx_info["psbt"])
         double_processed_psbt = self.nodes[0].walletprocesspsbt(
             complete_psbt["psbt"])
         assert_equal(complete_psbt, double_processed_psbt)
         # We don't care about the decode result, but decoding must succeed.
         self.nodes[0].decodepsbt(double_processed_psbt["psbt"])
 
         # BIP 174 Test Vectors
 
         # Check that unknown values are just passed through
         unknown_psbt = "cHNidP8BAD8CAAAAAf//////////////////////////////////////////AAAAAAD/////AQAAAAAAAAAAA2oBAAAAAAAACg8BAgMEBQYHCAkPAQIDBAUGBwgJCgsMDQ4PAAA="
         unknown_out = self.nodes[0].walletprocesspsbt(unknown_psbt)['psbt']
         assert_equal(unknown_psbt, unknown_out)
 
         # Open the data file
         with open(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'data/rpc_psbt.json'), encoding='utf-8') as f:
             d = json.load(f)
             invalids = d['invalid']
             valids = d['valid']
             creators = d['creator']
             signers = d['signer']
             combiners = d['combiner']
             finalizers = d['finalizer']
             extractors = d['extractor']
 
         # Invalid PSBTs
         for invalid in invalids:
             assert_raises_rpc_error(-22, "TX decode failed",
                                     self.nodes[0].decodepsbt, invalid)
 
         # Valid PSBTs
         for valid in valids:
             self.nodes[0].decodepsbt(valid)
 
         # Creator Tests
         for creator in creators:
             created_tx = self.nodes[0].createpsbt(
                 creator['inputs'], creator['outputs'])
             assert_equal(created_tx, creator['result'])
 
         # Signer tests
         for i, signer in enumerate(signers):
             self.nodes[2].createwallet("wallet{}".format(i))
             wrpc = self.nodes[2].get_wallet_rpc("wallet{}".format(i))
             for key in signer['privkeys']:
                 wrpc.importprivkey(key)
             signed_tx = wrpc.walletprocesspsbt(signer['psbt'])['psbt']
             assert_equal(signed_tx, signer['result'])
 
         # Combiner test
         for combiner in combiners:
             combined = self.nodes[2].combinepsbt(combiner['combine'])
             assert_equal(combined, combiner['result'])
 
         # Finalizer test
         for finalizer in finalizers:
             finalized = self.nodes[2].finalizepsbt(
                 finalizer['finalize'], False)['psbt']
             assert_equal(finalized, finalizer['result'])
 
         # Extractor test
         for extractor in extractors:
             extracted = self.nodes[2].finalizepsbt(
                 extractor['extract'], True)['hex']
             assert_equal(extracted, extractor['result'])
 
         # Test decoding error: invalid base64
         assert_raises_rpc_error(-22,
                                 "TX decode failed invalid base64",
                                 self.nodes[0].decodepsbt,
                                 ";definitely not base64;")
 
         # Test that psbts with p2pkh outputs are created properly
         p2pkh = self.nodes[0].getnewaddress()
         psbt = self.nodes[1].walletcreatefundedpsbt(
             [], [{p2pkh: 1}], 0, {"includeWatching": True}, True)
         self.nodes[0].decodepsbt(psbt['psbt'])
 
         # Send to all types of addresses
         addr1 = self.nodes[1].getnewaddress("")  # originally bech32
         txid1 = self.nodes[0].sendtoaddress(addr1, 11)
         vout1 = find_output(self.nodes[0], txid1, 11)
         addr2 = self.nodes[1].getnewaddress("")  # originally legacy
         txid2 = self.nodes[0].sendtoaddress(addr2, 11)
         vout2 = find_output(self.nodes[0], txid2, 11)
         addr3 = self.nodes[1].getnewaddress("")  # originally p2sh-segwit
         txid3 = self.nodes[0].sendtoaddress(addr3, 11)
         vout3 = find_output(self.nodes[0], txid3, 11)
         self.sync_all()
 
         # Update a PSBT with UTXOs from the node
         psbt = self.nodes[1].createpsbt([{"txid": txid1, "vout": vout1}, {"txid": txid2, "vout": vout2}, {
                                         "txid": txid3, "vout": vout3}], {self.nodes[0].getnewaddress(): 32.999})
         decoded = self.nodes[1].decodepsbt(psbt)
         updated = self.nodes[1].utxoupdatepsbt(psbt)
         decoded = self.nodes[1].decodepsbt(updated)
 
         # Two PSBTs with a common input should not be joinable
         psbt1 = self.nodes[1].createpsbt([{"txid": txid1, "vout": vout1}], {
                                          self.nodes[0].getnewaddress(): Decimal('10.999')})
         assert_raises_rpc_error(-8, "exists in multiple PSBTs",
                                 self.nodes[1].joinpsbts, [psbt1, updated])
 
         # Join two distinct PSBTs
         addr4 = self.nodes[1].getnewaddress("")
         txid4 = self.nodes[0].sendtoaddress(addr4, 5)
         vout4 = find_output(self.nodes[0], txid4, 5)
         self.nodes[0].generate(6)
         self.sync_all()
         psbt2 = self.nodes[1].createpsbt([{"txid": txid4, "vout": vout4}], {
                                          self.nodes[0].getnewaddress(): Decimal('4.999')})
         psbt2 = self.nodes[1].walletprocesspsbt(psbt2)['psbt']
         psbt2_decoded = self.nodes[0].decodepsbt(psbt2)
         assert "final_scriptSig" in psbt2_decoded['inputs'][0]
         joined = self.nodes[0].joinpsbts([psbt, psbt2])
         joined_decoded = self.nodes[0].decodepsbt(joined)
         assert len(joined_decoded['inputs']) == 4 and len(
             joined_decoded['outputs']) == 2 and "final_scriptSig" not in joined_decoded['inputs'][3]
 
         # Fail when trying to join less than two PSBTs
         assert_raises_rpc_error(-8,
                                 "At least two PSBTs are required to join PSBTs.", self.nodes[1].joinpsbts, [])
         assert_raises_rpc_error(-8,
                                 "At least two PSBTs are required to join PSBTs.", self.nodes[1].joinpsbts, [psbt2])
 
         # Newly created PSBT needs UTXOs and updating
         addr = self.nodes[1].getnewaddress("")
         txid = self.nodes[0].sendtoaddress(addr, 7)
         blockhash = self.nodes[0].generate(6)[0]
         self.sync_all()
         vout = find_output(self.nodes[0], txid, 7, blockhash=blockhash)
         psbt = self.nodes[1].createpsbt([{"txid": txid, "vout": vout}], {
                                         self.nodes[0].getnewaddress(""): Decimal('6.999')})
         analyzed = self.nodes[0].analyzepsbt(psbt)
         assert not analyzed['inputs'][0]['has_utxo'] and not analyzed['inputs'][0][
             'is_final'] and analyzed['inputs'][0]['next'] == 'updater' and analyzed['next'] == 'updater'
 
         # After update with wallet, only needs signing
         updated = self.nodes[1].walletprocesspsbt(
             psbt, False, 'ALL|FORKID', True)['psbt']
         analyzed = self.nodes[0].analyzepsbt(updated)
         assert analyzed['inputs'][0]['has_utxo'] and not analyzed['inputs'][0][
             'is_final'] and analyzed['inputs'][0]['next'] == 'signer' and analyzed['next'] == 'signer'
 
         # Check fee and size things
         assert analyzed['fee'] == Decimal(
-            '0.00100000') and analyzed['estimated_vsize'] == 191 and analyzed['estimated_feerate'] == '0.00523560 BCH/kB'
+            '0.00100000') and analyzed['estimated_vsize'] == 191 and analyzed['estimated_feerate'] == Decimal('0.00523560')
 
         # After signing and finalizing, needs extracting
         signed = self.nodes[1].walletprocesspsbt(updated)['psbt']
         analyzed = self.nodes[0].analyzepsbt(signed)
         assert analyzed['inputs'][0]['has_utxo'] and analyzed['inputs'][0]['is_final'] and analyzed['next'] == 'extractor'
 
 
 if __name__ == '__main__':
     PSBTTest().main()