diff --git a/src/core_io.h b/src/core_io.h
--- a/src/core_io.h
+++ b/src/core_io.h
@@ -5,6 +5,8 @@
 #ifndef BITCOIN_CORE_IO_H
 #define BITCOIN_CORE_IO_H
 
+#include <script/sighashtype.h>
+
 #include <string>
 #include <vector>
 
@@ -29,6 +31,7 @@
 std::vector<uint8_t> ParseHexUV(const UniValue &v, const std::string &strName);
 bool DecodePSBT(PartiallySignedTransaction &psbt, const std::string &base64_tx,
                 std::string &error);
+SigHashType ParseSighashString(const UniValue &sighash);
 
 // core_write.cpp
 UniValue ValueFromAmount(const Amount &amount);
diff --git a/src/core_read.cpp b/src/core_read.cpp
--- a/src/core_read.cpp
+++ b/src/core_read.cpp
@@ -296,3 +296,35 @@
 
     return ParseHex(strHex);
 }
+
+SigHashType ParseSighashString(const UniValue &sighash) {
+    SigHashType sigHashType = SigHashType().withForkId();
+    if (!sighash.isNull()) {
+        static std::map<std::string, int> map_sighash_values = {
+            {"ALL", SIGHASH_ALL},
+            {"ALL|ANYONECANPAY", SIGHASH_ALL | SIGHASH_ANYONECANPAY},
+            {"ALL|FORKID", SIGHASH_ALL | SIGHASH_FORKID},
+            {"ALL|FORKID|ANYONECANPAY",
+             SIGHASH_ALL | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
+            {"NONE", SIGHASH_NONE},
+            {"NONE|ANYONECANPAY", SIGHASH_NONE | SIGHASH_ANYONECANPAY},
+            {"NONE|FORKID", SIGHASH_NONE | SIGHASH_FORKID},
+            {"NONE|FORKID|ANYONECANPAY",
+             SIGHASH_NONE | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
+            {"SINGLE", SIGHASH_SINGLE},
+            {"SINGLE|ANYONECANPAY", SIGHASH_SINGLE | SIGHASH_ANYONECANPAY},
+            {"SINGLE|FORKID", SIGHASH_SINGLE | SIGHASH_FORKID},
+            {"SINGLE|FORKID|ANYONECANPAY",
+             SIGHASH_SINGLE | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
+        };
+        std::string strHashType = sighash.get_str();
+        const auto &it = map_sighash_values.find(strHashType);
+        if (it != map_sighash_values.end()) {
+            sigHashType = SigHashType(it->second);
+        } else {
+            throw std::runtime_error(strHashType +
+                                     " is not a valid sighash parameter.");
+        }
+    }
+    return sigHashType;
+}
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -101,6 +101,13 @@
     {"testmempoolaccept", 1, "allowhighfees"},
     {"combinerawtransaction", 0, "txs"},
     {"fundrawtransaction", 1, "options"},
+    {"walletcreatefundedpsbt", 0, "inputs"},
+    {"walletcreatefundedpsbt", 1, "outputs"},
+    {"walletcreatefundedpsbt", 2, "locktime"},
+    {"walletcreatefundedpsbt", 3, "options"},
+    {"walletcreatefundedpsbt", 4, "bip32derivs"},
+    {"walletprocesspsbt", 1, "sign"},
+    {"walletprocesspsbt", 3, "bip32derivs"},
     {"createpsbt", 0, "inputs"},
     {"createpsbt", 1, "outputs"},
     {"createpsbt", 2, "locktime"},
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -946,35 +946,10 @@
         }
     }
 
-    SigHashType sigHashType = SigHashType().withForkId();
-    if (!hashType.isNull()) {
-        static std::map<std::string, int> mapSigHashValues = {
-            {"ALL", SIGHASH_ALL},
-            {"ALL|ANYONECANPAY", SIGHASH_ALL | SIGHASH_ANYONECANPAY},
-            {"ALL|FORKID", SIGHASH_ALL | SIGHASH_FORKID},
-            {"ALL|FORKID|ANYONECANPAY",
-             SIGHASH_ALL | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
-            {"NONE", SIGHASH_NONE},
-            {"NONE|ANYONECANPAY", SIGHASH_NONE | SIGHASH_ANYONECANPAY},
-            {"NONE|FORKID", SIGHASH_NONE | SIGHASH_FORKID},
-            {"NONE|FORKID|ANYONECANPAY",
-             SIGHASH_NONE | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
-            {"SINGLE", SIGHASH_SINGLE},
-            {"SINGLE|ANYONECANPAY", SIGHASH_SINGLE | SIGHASH_ANYONECANPAY},
-            {"SINGLE|FORKID", SIGHASH_SINGLE | SIGHASH_FORKID},
-            {"SINGLE|FORKID|ANYONECANPAY",
-             SIGHASH_SINGLE | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
-        };
-        std::string strHashType = hashType.get_str();
-        if (!mapSigHashValues.count(strHashType)) {
-            throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid sighash param");
-        }
-
-        sigHashType = SigHashType(mapSigHashValues[strHashType]);
-        if (!sigHashType.hasForkId()) {
-            throw JSONRPCError(RPC_INVALID_PARAMETER,
-                               "Signature must use SIGHASH_FORKID");
-        }
+    SigHashType sigHashType = ParseSighashString(hashType);
+    if (!sigHashType.hasForkId()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER,
+                           "Signature must use SIGHASH_FORKID");
     }
 
     // Script verification errors.
@@ -1015,9 +990,8 @@
                 // Unable to sign input and verification failed (possible
                 // attempt to partially sign).
                 TxInErrorToJSON(txin, vErrors,
-                                "Unable to sign input, invalid "
-                                "stack size (possibly missing "
-                                "key)");
+                                "Unable to sign input, invalid stack size "
+                                "(possibly missing key)");
             } else {
                 TxInErrorToJSON(txin, vErrors, ScriptErrorString(serror));
             }
diff --git a/src/script/sighashtype.h b/src/script/sighashtype.h
--- a/src/script/sighashtype.h
+++ b/src/script/sighashtype.h
@@ -89,6 +89,19 @@
     template <typename Stream> void Unserialize(Stream &s) {
         ::Unserialize(s, sigHash);
     }
+
+    /**
+     * Handy operators.
+     */
+    friend constexpr bool operator==(const SigHashType &a,
+                                     const SigHashType &b) {
+        return a.sigHash == b.sigHash;
+    }
+
+    friend constexpr bool operator!=(const SigHashType &a,
+                                     const SigHashType &b) {
+        return !(a == b);
+    }
 };
 
 #endif // BITCOIN_SCRIPT_SIGHASHTYPE_H
diff --git a/src/script/sign.h b/src/script/sign.h
--- a/src/script/sign.h
+++ b/src/script/sign.h
@@ -38,6 +38,17 @@
 
 extern const SigningProvider &DUMMY_SIGNING_PROVIDER;
 
+class PublicOnlySigningProvider : public SigningProvider {
+private:
+    const SigningProvider *m_provider;
+
+public:
+    PublicOnlySigningProvider(const SigningProvider *provider)
+        : m_provider(provider) {}
+    bool GetCScript(const CScriptID &scriptid, CScript &script) const;
+    bool GetPubKey(const CKeyID &address, CPubKey &pubkey) const;
+};
+
 /** Interface for signature creators. */
 class BaseSignatureCreator {
 public:
diff --git a/src/script/sign.cpp b/src/script/sign.cpp
--- a/src/script/sign.cpp
+++ b/src/script/sign.cpp
@@ -544,3 +544,13 @@
         redeem_script = output.redeem_script;
     }
 }
+
+bool PublicOnlySigningProvider::GetCScript(const CScriptID &scriptid,
+                                           CScript &script) const {
+    return m_provider->GetCScript(scriptid, script);
+}
+
+bool PublicOnlySigningProvider::GetPubKey(const CKeyID &address,
+                                          CPubKey &pubkey) const {
+    return m_provider->GetPubKey(address, pubkey);
+}
diff --git a/src/wallet/rpcwallet.h b/src/wallet/rpcwallet.h
--- a/src/wallet/rpcwallet.h
+++ b/src/wallet/rpcwallet.h
@@ -5,14 +5,17 @@
 #ifndef BITCOIN_WALLET_RPCWALLET_H
 #define BITCOIN_WALLET_RPCWALLET_H
 
+#include <script/sighashtype.h>
+
 #include <string>
 
+class Config;
 class CRPCTable;
+class CTransaction;
 class CWallet;
 class JSONRPCRequest;
-class CWallet;
+struct PartiallySignedTransaction;
 class UniValue;
-class Config;
 
 void RegisterWalletRPCCommands(CRPCTable &t);
 
@@ -32,5 +35,9 @@
 UniValue signrawtransactionwithwallet(const Config &config,
                                       const JSONRPCRequest &request);
 UniValue getaddressinfo(const Config &config, const JSONRPCRequest &request);
+bool FillPSBT(const CWallet *pwallet, PartiallySignedTransaction &psbtx,
+              const CTransaction *txConst,
+              SigHashType sighash_type = SigHashType(), bool sign = true,
+              bool bip32derivs = false);
 
 #endif // BITCOIN_WALLET_RPCWALLET_H
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -4740,8 +4740,7 @@
             "  \"script\" : \"type\"             (string, optional) The output "
             "script type. Only if \"isscript\" is true and the redeemscript is "
             "known. Possible types: nonstandard, pubkey, pubkeyhash, "
-            "scripthash, multisig, nulldata, witness_v0_keyhash, "
-            "witness_v0_scripthash, witness_unknown\n"
+            "scripthash, multisig, nulldata\n"
             "  \"hex\" : \"hex\",                (string, optional) The "
             "redeemscript for the p2sh address\n"
             "  \"pubkeys\"                     (string, optional) Array of "
@@ -5060,11 +5059,399 @@
     return NullUniValue;
 }
 
+static bool ParseHDKeypath(std::string keypath_str,
+                           std::vector<uint32_t> &keypath) {
+    std::stringstream ss(keypath_str);
+    std::string item;
+    bool first = true;
+    while (std::getline(ss, item, '/')) {
+        if (item.compare("m") == 0) {
+            if (first) {
+                first = false;
+                continue;
+            }
+            return false;
+        }
+        // Finds whether it is hardened
+        uint32_t path = 0;
+        size_t pos = item.find("'");
+        if (pos != std::string::npos) {
+            // The hardened tick can only be in the last index of the string
+            if (pos != item.size() - 1) {
+                return false;
+            }
+            path |= 0x80000000;
+            // Drop the last character which is the hardened tick
+            item = item.substr(0, item.size() - 1);
+        }
+
+        // Ensure this is only numbers
+        if (item.find_first_not_of("0123456789") != std::string::npos) {
+            return false;
+        }
+        uint32_t number;
+        ParseUInt32(item, &number);
+        path |= number;
+
+        keypath.push_back(path);
+        first = false;
+    }
+    return true;
+}
+
+static void
+AddKeypathToMap(const CWallet *pwallet, const CKeyID &keyID,
+                std::map<CPubKey, std::vector<uint32_t>> &hd_keypaths) {
+    CPubKey vchPubKey;
+    if (!pwallet->GetPubKey(keyID, vchPubKey)) {
+        return;
+    }
+    CKeyMetadata meta;
+    auto it = pwallet->mapKeyMetadata.find(keyID);
+    if (it != pwallet->mapKeyMetadata.end()) {
+        meta = it->second;
+    }
+    std::vector<uint32_t> keypath;
+    if (!meta.hdKeypath.empty()) {
+        if (!ParseHDKeypath(meta.hdKeypath, keypath)) {
+            throw JSONRPCError(RPC_INTERNAL_ERROR,
+                               "Internal keypath is broken");
+        }
+        // Get the proper master key id
+        CKey key;
+        pwallet->GetKey(meta.hd_seed_id, key);
+        CExtKey masterKey;
+        masterKey.SetSeed(key.begin(), key.size());
+        // Add to map
+        keypath.insert(keypath.begin(),
+                       ReadLE32(masterKey.key.GetPubKey().GetID().begin()));
+    } else {
+        // Single pubkeys get the master fingerprint of themselves
+        keypath.insert(keypath.begin(), ReadLE32(vchPubKey.GetID().begin()));
+    }
+    hd_keypaths.emplace(vchPubKey, keypath);
+}
+
+bool FillPSBT(const CWallet *pwallet, PartiallySignedTransaction &psbtx,
+              const CTransaction *txConst, SigHashType sighash_type, bool sign,
+              bool bip32derivs) {
+    LOCK(pwallet->cs_wallet);
+    // Get all of the previous transactions
+    bool complete = true;
+    for (size_t i = 0; i < txConst->vin.size(); ++i) {
+        const CTxIn &txin = txConst->vin[i];
+        PSBTInput &input = psbtx.inputs.at(i);
+
+        // If we don't know about this input, skip it and let someone else deal
+        // with it
+        const TxId &txid = txin.prevout.GetTxId();
+        const auto &it = pwallet->mapWallet.find(txid);
+        if (it != pwallet->mapWallet.end()) {
+            const CWalletTx &wtx = it->second;
+            CTxOut utxo = wtx.tx->vout[txin.prevout.GetN()];
+            input.utxo = utxo;
+        }
+
+        // Get the Sighash type
+        if (sign && input.sighash_type.getRawSigHashType() > 0 &&
+            input.sighash_type != sighash_type) {
+            throw JSONRPCError(
+                RPC_DESERIALIZATION_ERROR,
+                "Specified sighash and sighash in PSBT do not match.");
+        }
+
+        SignatureData sigdata;
+        if (sign) {
+            complete &= SignPSBTInput(*pwallet, *psbtx.tx, input, sigdata, i,
+                                      sighash_type);
+        } else {
+            complete &=
+                SignPSBTInput(PublicOnlySigningProvider(pwallet), *psbtx.tx,
+                              input, sigdata, i, sighash_type);
+        }
+
+        // Get public key paths
+        if (bip32derivs) {
+            for (const auto &pubkey_it : sigdata.misc_pubkeys) {
+                AddKeypathToMap(pwallet, pubkey_it.first, input.hd_keypaths);
+            }
+        }
+    }
+
+    // Fill in the bip32 keypaths and redeemscripts for the outputs so that
+    // hardware wallets can identify change
+    for (unsigned int i = 0; i < txConst->vout.size(); ++i) {
+        const CTxOut &out = txConst->vout.at(i);
+        PSBTOutput &psbt_out = psbtx.outputs.at(i);
+
+        // Dummy tx so we can use ProduceSignature to get stuff out
+        CMutableTransaction dummy_tx;
+        dummy_tx.vin.push_back(CTxIn());
+        dummy_tx.vout.push_back(CTxOut());
+
+        // Fill a SignatureData with output info
+        SignatureData sigdata;
+        psbt_out.FillSignatureData(sigdata);
+
+        MutableTransactionSignatureCreator creator(
+            psbtx.tx.get_ptr(), 0, out.nValue, SigHashType().withForkId());
+        ProduceSignature(*pwallet, creator, out.scriptPubKey, sigdata);
+        psbt_out.FromSignatureData(sigdata);
+
+        // Get public key paths
+        if (bip32derivs) {
+            for (const auto &pubkey_it : sigdata.misc_pubkeys) {
+                AddKeypathToMap(pwallet, pubkey_it.first, psbt_out.hd_keypaths);
+            }
+        }
+    }
+    return complete;
+}
+
+static UniValue walletprocesspsbt(const Config &config,
+                                  const JSONRPCRequest &request) {
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    CWallet *const pwallet = wallet.get();
+
+    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
+        return NullUniValue;
+    }
+
+    if (request.fHelp || request.params.size() < 1 ||
+        request.params.size() > 4) {
+        throw std::runtime_error(
+            "walletprocesspsbt \"psbt\" ( sign \"sighashtype\" bip32derivs )\n"
+            "\nUpdate a PSBT with input information from our wallet and then "
+            "sign inputs\n"
+            "that we can sign for.\n" +
+            HelpRequiringPassphrase(pwallet) +
+            "\n"
+
+            "\nArguments:\n"
+            "1. \"psbt\"                      (string, required) The "
+            "transaction base64 string\n"
+            "2. sign                          (boolean, optional, "
+            "default=true) Also sign the transaction when updating\n"
+            "3. \"sighashtype\"            (string, optional, "
+            "default=ALL|FORKID) The signature hash type to sign with if not "
+            "specified by the PSBT. 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\"\n"
+            "4. bip32derivs                    (boolean, optiona, "
+            "default=false) If true, includes the BIP 32 derivation paths for "
+            "public keys if we know them\n"
+
+            "\nResult:\n"
+            "{\n"
+            "  \"psbt\" : \"value\",          (string) The base64-encoded "
+            "partially signed transaction\n"
+            "  \"complete\" : true|false,   (boolean) If the transaction has a "
+            "complete set of signatures\n"
+            "  ]\n"
+            "}\n"
+
+            "\nExamples:\n" +
+            HelpExampleCli("walletprocesspsbt", "\"psbt\""));
+    }
+
+    RPCTypeCheck(request.params,
+                 {UniValue::VSTR, UniValue::VBOOL, UniValue::VSTR});
+
+    // Unserialize the transaction
+    PartiallySignedTransaction psbtx;
+    std::string error;
+    if (!DecodePSBT(psbtx, request.params[0].get_str(), error)) {
+        throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
+                           strprintf("TX decode failed %s", error));
+    }
+
+    // Get the sighash type
+    SigHashType nHashType = ParseSighashString(request.params[2]);
+    if (!nHashType.hasForkId()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER,
+                           "Signature must use SIGHASH_FORKID");
+    }
+
+    // Use CTransaction for the constant parts of the
+    // transaction to avoid rehashing.
+    const CTransaction txConst(*psbtx.tx);
+
+    // Fill transaction with our data and also sign
+    bool sign =
+        request.params[1].isNull() ? true : request.params[1].get_bool();
+    bool bip32derivs =
+        request.params[3].isNull() ? false : request.params[3].get_bool();
+    bool complete =
+        FillPSBT(pwallet, psbtx, &txConst, nHashType, sign, bip32derivs);
+
+    UniValue result(UniValue::VOBJ);
+    CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
+    ssTx << psbtx;
+    result.pushKV("psbt", EncodeBase64((uint8_t *)ssTx.data(), ssTx.size()));
+    result.pushKV("complete", complete);
+
+    return result;
+}
+
+static UniValue walletcreatefundedpsbt(const Config &config,
+                                       const JSONRPCRequest &request) {
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    CWallet *const pwallet = wallet.get();
+
+    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
+        return NullUniValue;
+    }
+
+    if (request.fHelp || request.params.size() < 2 ||
+        request.params.size() > 5) {
+        throw std::runtime_error(
+            "walletcreatefundedpsbt [{\"txid\":\"id\",\"vout\":n},...] "
+            "[{\"address\":amount},{\"data\":\"hex\"},...] ( locktime ) ( "
+            "options bip32derivs )\n"
+            "\nCreates and funds a transaction in the Partially Signed "
+            "Transaction format. Inputs will be added if supplied inputs are "
+            "not enough\n"
+            "Implements the Creator and Updater roles.\n"
+            "\nArguments:\n"
+            "1. \"inputs\"                (array, required) A json array of "
+            "json objects\n"
+            "     [\n"
+            "       {\n"
+            "         \"txid\":\"id\",      (string, required) The transaction "
+            "id\n"
+            "         \"vout\":n,         (numeric, required) The output "
+            "number\n"
+            "         \"sequence\":n      (numeric, optional) The sequence "
+            "number\n"
+            "       } \n"
+            "       ,...\n"
+            "     ]\n"
+            "2. \"outputs\"               (array, required) a json array with "
+            "outputs (key-value pairs)\n"
+            "   [\n"
+            "    {\n"
+            "      \"address\": x.xxx,    (obj, optional) A key-value pair. "
+            "The key (string) is the bitcoin address, the value (float or "
+            "string) is the amount in " +
+            CURRENCY_UNIT +
+            "\n"
+            "    },\n"
+            "    {\n"
+            "      \"data\": \"hex\"        (obj, optional) A key-value pair. "
+            "The key must be \"data\", the value is hex encoded data\n"
+            "    }\n"
+            "    ,...                     More key-value pairs of the above "
+            "form. For compatibility reasons, a dictionary, which holds the "
+            "key-value pairs directly, is also\n"
+            "                             accepted as second parameter.\n"
+            "   ]\n"
+            "3. locktime                  (numeric, optional, default=0) Raw "
+            "locktime. Non-0 value also locktime-activates inputs\n"
+            "4. options                 (object, optional)\n"
+            "   {\n"
+            "     \"changeAddress\"          (string, optional, default pool "
+            "address) The bitcoin address to receive the change\n"
+            "     \"changePosition\"         (numeric, optional, default "
+            "random) The index of the change output\n"
+            "     \"change_type\"            (string, optional) The output "
+            "type to use. Only valid if changeAddress is not specified. "
+            "Options are \"legacy\", \"p2sh-segwit\", and \"bech32\". Default "
+            "is set by -changetype.\n"
+            "     \"includeWatching\"        (boolean, optional, default "
+            "false) Also select inputs which are watch only\n"
+            "     \"lockUnspents\"           (boolean, optional, default "
+            "false) Lock selected unspent outputs\n"
+            "     \"feeRate\"                (numeric, optional, default not "
+            "set: makes wallet determine the fee) Set a specific fee rate in " +
+            CURRENCY_UNIT +
+            "/kB\n"
+            "     \"subtractFeeFromOutputs\" (array, optional) A json array of "
+            "integers.\n"
+            "                              The fee will be equally deducted "
+            "from the amount of each specified output.\n"
+            "                              The outputs are specified by their "
+            "zero-based index, before any change output is added.\n"
+            "                              Those recipients will receive less "
+            "bitcoins than you enter in their corresponding amount field.\n"
+            "                              If no outputs are specified here, "
+            "the sender pays the fee.\n"
+            "                                  [vout_index,...]\n"
+            "   }\n"
+            "5. bip32derivs                    (boolean, optiona, "
+            "default=false) If true, includes the BIP 32 derivation paths for "
+            "public keys if we know them\n"
+            "\nResult:\n"
+            "{\n"
+            "  \"psbt\": \"value\",        (string)  The resulting raw "
+            "transaction (base64-encoded string)\n"
+            "  \"fee\":       n,         (numeric) Fee in " +
+            CURRENCY_UNIT +
+            " the resulting transaction pays\n"
+            "  \"changepos\": n          (numeric) The position of the added "
+            "change output, or -1\n"
+            "}\n"
+            "\nExamples:\n"
+            "\nCreate a transaction with no inputs\n" +
+            HelpExampleCli("walletcreatefundedpsbt",
+                           "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" "
+                           "\"[{\\\"data\\\":\\\"00010203\\\"}]\""));
+    }
+
+    RPCTypeCheck(request.params,
+                 {UniValue::VARR,
+                  UniValueType(), // ARR or OBJ, checked later
+                  UniValue::VNUM, UniValue::VOBJ},
+                 true);
+
+    Amount fee;
+    int change_position;
+    CMutableTransaction rawTx =
+        ConstructTransaction(config.GetChainParams(), request.params[0],
+                             request.params[1], request.params[2]);
+    FundTransaction(pwallet, rawTx, fee, change_position, request.params[3]);
+
+    // 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());
+    }
+
+    // Use CTransaction for the constant parts of the
+    // transaction to avoid rehashing.
+    const CTransaction txConst(*psbtx.tx);
+
+    // Fill transaction with out data but don't sign
+    bool bip32derivs =
+        request.params[4].isNull() ? false : request.params[4].get_bool();
+    FillPSBT(pwallet, psbtx, &txConst, SigHashType().withForkId(), false,
+             bip32derivs);
+
+    // Serialize the PSBT
+    CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
+    ssTx << psbtx;
+
+    UniValue result(UniValue::VOBJ);
+    result.pushKV("psbt", EncodeBase64((uint8_t *)ssTx.data(), ssTx.size()));
+    result.pushKV("fee", ValueFromAmount(fee));
+    result.pushKV("changepos", change_position);
+    return result;
+}
+
 // clang-format off
 static const ContextFreeRPCCommand commands[] = {
     //  category            name                            actor (function)              argNames
     //  ------------------- ------------------------        ----------------------        ----------
     { "rawtransactions",    "fundrawtransaction",           fundrawtransaction,           {"hexstring","options"} },
+    { "wallet",             "walletprocesspsbt",            walletprocesspsbt,            {"psbt","sign","sighashtype","bip32derivs"} },
+    { "wallet",             "walletcreatefundedpsbt",       walletcreatefundedpsbt,       {"inputs","outputs","locktime","options","bip32derivs"} },
     { "hidden",             "resendwallettransactions",     resendwallettransactions,     {} },
     { "wallet",             "abandontransaction",           abandontransaction,           {"txid"} },
     { "wallet",             "addmultisigaddress",           addmultisigaddress,           {"nrequired","keys","label|account"} },
diff --git a/test/functional/rpc_signrawtransaction.py b/test/functional/rpc_signrawtransaction.py
--- a/test/functional/rpc_signrawtransaction.py
+++ b/test/functional/rpc_signrawtransaction.py
@@ -149,7 +149,7 @@
             "SINGLE|FORKID",
             "ALL|FORKID|ANYONECANPAY",
             "NONE|FORKID|ANYONECANPAY",
-            "SINGLE|FORKID|ANYONECANPAY"
+            "SINGLE|FORKID|ANYONECANPAY",
         ]
         no_forkid_sighashes = [
             "ALL",
@@ -157,13 +157,13 @@
             "SINGLE",
             "ALL|ANYONECANPAY",
             "NONE|ANYONECANPAY",
-            "SINGLE|ANYONECANPAY"
+            "SINGLE|ANYONECANPAY",
         ]
         invalid_sighashes = [
             "",
             "ALL|SINGLE|FORKID",
             str(0),
-            str(0x20)
+            str(0x20),
         ]
 
         # 1) If the sighash is valid with FORKID, the signature is complete
@@ -182,7 +182,7 @@
 
         # 3) If the sighash is invalid the RPC throws an error
         for sighash in invalid_sighashes:
-            assert_raises_rpc_error(-8, "Invalid sighash param",
+            assert_raises_rpc_error(-1, sighash + " is not a valid sighash parameter.",
                                     self.nodes[0].signrawtransactionwithkey,
                                     rawTx, privKeys, inputs, sighash)