diff --git a/src/psbt.h b/src/psbt.h
--- a/src/psbt.h
+++ b/src/psbt.h
@@ -7,6 +7,7 @@
 
 #include <attributes.h>
 #include <node/transaction.h>
+#include <optional.h>
 #include <primitives/transaction.h>
 #include <pubkey.h>
 #include <script/sign.h>
@@ -481,8 +482,35 @@
     }
 };
 
+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
@@ -527,6 +555,15 @@
 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,
diff --git a/src/psbt.cpp b/src/psbt.cpp
--- a/src/psbt.cpp
+++ b/src/psbt.cpp
@@ -2,9 +2,14 @@
 // 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) {
@@ -168,7 +173,7 @@
     }
 }
 
-bool PSBTInputSigned(PSBTInput &input) {
+bool PSBTInputSigned(const PSBTInput &input) {
     return !input.final_script_sig.empty();
 }
 
@@ -273,6 +278,144 @@
     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;
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -36,7 +36,6 @@
 #include <validationinterface.h>
 
 #include <cstdint>
-#include <numeric>
 
 #include <univalue.h>
 
@@ -1897,147 +1896,54 @@
                            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;
 }
 
diff --git a/test/functional/rpc_psbt.py b/test/functional/rpc_psbt.py
--- a/test/functional/rpc_psbt.py
+++ b/test/functional/rpc_psbt.py
@@ -299,7 +299,7 @@
 
         # 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']