diff --git a/src/script/sign.cpp b/src/script/sign.cpp
index 23f3b09eb..6066e67df 100644
--- a/src/script/sign.cpp
+++ b/src/script/sign.cpp
@@ -1,494 +1,496 @@
 // Copyright (c) 2009-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 <script/sign.h>
 
 #include <key.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <script/standard.h>
 #include <uint256.h>
 
 typedef std::vector<uint8_t> valtype;
 
 MutableTransactionSignatureCreator::MutableTransactionSignatureCreator(
     const CMutableTransaction *txToIn, unsigned int nInIn,
     const Amount &amountIn, SigHashType sigHashTypeIn)
     : txTo(txToIn), nIn(nInIn), amount(amountIn), sigHashType(sigHashTypeIn),
       checker(txTo, nIn, amountIn) {}
 
 bool MutableTransactionSignatureCreator::CreateSig(
     const SigningProvider &provider, std::vector<uint8_t> &vchSig,
     const CKeyID &address, const CScript &scriptCode) const {
     CKey key;
     if (!provider.GetKey(address, key)) {
         return false;
     }
 
     uint256 hash = SignatureHash(scriptCode, *txTo, nIn, sigHashType, amount);
     if (!key.SignECDSA(hash, vchSig)) {
         return false;
     }
 
     vchSig.push_back(uint8_t(sigHashType.getRawSigHashType()));
     return true;
 }
 
 static bool GetCScript(const SigningProvider &provider,
                        const SignatureData &sigdata, const CScriptID &scriptid,
                        CScript &script) {
     if (provider.GetCScript(scriptid, script)) {
         return true;
     }
     // Look for scripts in SignatureData
     if (CScriptID(sigdata.redeem_script) == scriptid) {
         script = sigdata.redeem_script;
         return true;
     }
     return false;
 }
 
 static bool GetPubKey(const SigningProvider &provider, SignatureData &sigdata,
                       const CKeyID &address, CPubKey &pubkey) {
     // Look for pubkey in all partial sigs
     const auto it = sigdata.signatures.find(address);
     if (it != sigdata.signatures.end()) {
         pubkey = it->second.first;
         return true;
     }
     // Look for pubkey in pubkey list
     const auto &pk_it = sigdata.misc_pubkeys.find(address);
     if (pk_it != sigdata.misc_pubkeys.end()) {
         pubkey = pk_it->second.first;
         return true;
     }
     // Query the underlying provider
     if (provider.GetPubKey(address, pubkey)) {
         KeyOriginInfo info;
         if (provider.GetKeyOrigin(address, info)) {
             sigdata.misc_pubkeys.emplace(
                 address, std::make_pair(pubkey, std::move(info)));
         }
         return true;
     }
     return false;
 }
 
 static bool CreateSig(const BaseSignatureCreator &creator,
                       SignatureData &sigdata, const SigningProvider &provider,
                       std::vector<uint8_t> &sig_out, const CPubKey &pubkey,
                       const CScript &scriptcode) {
     CKeyID keyid = pubkey.GetID();
     const auto it = sigdata.signatures.find(keyid);
     if (it != sigdata.signatures.end()) {
         sig_out = it->second.second;
         return true;
     }
     KeyOriginInfo info;
     if (provider.GetKeyOrigin(keyid, info)) {
         sigdata.misc_pubkeys.emplace(keyid,
                                      std::make_pair(pubkey, std::move(info)));
     }
     if (creator.CreateSig(provider, sig_out, keyid, scriptcode)) {
         auto i = sigdata.signatures.emplace(keyid, SigPair(pubkey, sig_out));
         assert(i.second);
         return true;
     }
     return false;
 }
 
 /**
  * Sign scriptPubKey using signature made with creator.
  * Signatures are returned in scriptSigRet (or returns false if scriptPubKey
  * can't be signed), unless whichTypeRet is TX_SCRIPTHASH, in which case
  * scriptSigRet is the redemption script.
  * Returns false if scriptPubKey could not be completely satisfied.
  */
 static bool SignStep(const SigningProvider &provider,
                      const BaseSignatureCreator &creator,
                      const CScript &scriptPubKey, std::vector<valtype> &ret,
                      txnouttype &whichTypeRet, SignatureData &sigdata) {
     CScript scriptRet;
     uint160 h160;
     ret.clear();
     std::vector<uint8_t> sig;
 
     std::vector<valtype> vSolutions;
     whichTypeRet = Solver(scriptPubKey, vSolutions);
 
     switch (whichTypeRet) {
         case TX_NONSTANDARD:
         case TX_NULL_DATA:
             return false;
         case TX_PUBKEY:
             if (!CreateSig(creator, sigdata, provider, sig,
                            CPubKey(vSolutions[0]), scriptPubKey)) {
                 return false;
             }
             ret.push_back(std::move(sig));
             return true;
         case TX_PUBKEYHASH: {
             CKeyID keyID = CKeyID(uint160(vSolutions[0]));
             CPubKey pubkey;
-            provider.GetPubKey(keyID, pubkey);
+            if (!provider.GetPubKey(keyID, pubkey)) {
+                return false;
+            }
             if (!CreateSig(creator, sigdata, provider, sig, pubkey,
                            scriptPubKey)) {
                 return false;
             }
             ret.push_back(std::move(sig));
             ret.push_back(ToByteVector(pubkey));
             return true;
         }
         case TX_SCRIPTHASH:
             if (GetCScript(provider, sigdata, uint160(vSolutions[0]),
                            scriptRet)) {
                 ret.push_back(
                     std::vector<uint8_t>(scriptRet.begin(), scriptRet.end()));
                 return true;
             }
             return false;
         case TX_MULTISIG: {
             size_t required = vSolutions.front()[0];
             // workaround CHECKMULTISIG bug
             ret.push_back(valtype());
             for (size_t i = 1; i < vSolutions.size() - 1; ++i) {
                 CPubKey pubkey = CPubKey(vSolutions[i]);
                 if (ret.size() < required + 1 &&
                     CreateSig(creator, sigdata, provider, sig, pubkey,
                               scriptPubKey)) {
                     ret.push_back(std::move(sig));
                 }
             }
             bool ok = ret.size() == required + 1;
             for (size_t i = 0; i + ret.size() < required + 1; ++i) {
                 ret.push_back(valtype());
             }
             return ok;
         }
         default:
             return false;
     }
 }
 
 static CScript PushAll(const std::vector<valtype> &values) {
     CScript result;
     for (const valtype &v : values) {
         if (v.size() == 0) {
             result << OP_0;
         } else if (v.size() == 1 && v[0] >= 1 && v[0] <= 16) {
             result << CScript::EncodeOP_N(v[0]);
         } else {
             result << v;
         }
     }
 
     return result;
 }
 
 bool ProduceSignature(const SigningProvider &provider,
                       const BaseSignatureCreator &creator,
                       const CScript &fromPubKey, SignatureData &sigdata) {
     if (sigdata.complete) {
         return true;
     }
 
     std::vector<valtype> result;
     txnouttype whichType;
     bool solved =
         SignStep(provider, creator, fromPubKey, result, whichType, sigdata);
     CScript subscript;
 
     if (solved && whichType == TX_SCRIPTHASH) {
         // Solver returns the subscript that needs to be evaluated; the final
         // scriptSig is the signatures from that and then the serialized
         // subscript:
         subscript = CScript(result[0].begin(), result[0].end());
         sigdata.redeem_script = subscript;
 
         solved = solved &&
                  SignStep(provider, creator, subscript, result, whichType,
                           sigdata) &&
                  whichType != TX_SCRIPTHASH;
         result.push_back(
             std::vector<uint8_t>(subscript.begin(), subscript.end()));
     }
 
     sigdata.scriptSig = PushAll(result);
 
     // Test solution
     sigdata.complete =
         solved && VerifyScript(sigdata.scriptSig, fromPubKey,
                                STANDARD_SCRIPT_VERIFY_FLAGS, creator.Checker());
     return sigdata.complete;
 }
 
 class SignatureExtractorChecker final : public BaseSignatureChecker {
 private:
     SignatureData &sigdata;
     BaseSignatureChecker &checker;
 
 public:
     SignatureExtractorChecker(SignatureData &sigdata_,
                               BaseSignatureChecker &checker_)
         : sigdata(sigdata_), checker(checker_) {}
     bool CheckSig(const std::vector<uint8_t> &scriptSig,
                   const std::vector<uint8_t> &vchPubKey,
                   const CScript &scriptCode, uint32_t flags) const override;
 };
 
 bool SignatureExtractorChecker::CheckSig(const std::vector<uint8_t> &scriptSig,
                                          const std::vector<uint8_t> &vchPubKey,
                                          const CScript &scriptCode,
                                          uint32_t flags) const {
     if (checker.CheckSig(scriptSig, vchPubKey, scriptCode, flags)) {
         CPubKey pubkey(vchPubKey);
         sigdata.signatures.emplace(pubkey.GetID(), SigPair(pubkey, scriptSig));
         return true;
     }
     return false;
 }
 
 namespace {
 struct Stacks {
     std::vector<valtype> script;
 
     Stacks() = delete;
     Stacks(const Stacks &) = delete;
     explicit Stacks(const SignatureData &data) {
         if (data.scriptSig.IsPushOnly()) {
             EvalScript(script, data.scriptSig, SCRIPT_VERIFY_NONE,
                        BaseSignatureChecker());
         }
     }
 };
 } // namespace
 
 // Extracts signatures and scripts from incomplete scriptSigs. Please do not
 // extend this, use PSBT instead
 SignatureData DataFromTransaction(const CMutableTransaction &tx,
                                   unsigned int nIn, const CTxOut &txout) {
     SignatureData data;
     assert(tx.vin.size() > nIn);
     data.scriptSig = tx.vin[nIn].scriptSig;
     Stacks stack(data);
 
     // Get signatures
     MutableTransactionSignatureChecker tx_checker(&tx, nIn, txout.nValue);
     SignatureExtractorChecker extractor_checker(data, tx_checker);
     if (VerifyScript(data.scriptSig, txout.scriptPubKey,
                      STANDARD_SCRIPT_VERIFY_FLAGS, extractor_checker)) {
         data.complete = true;
         return data;
     }
 
     // Get scripts
     std::vector<std::vector<uint8_t>> solutions;
     txnouttype script_type = Solver(txout.scriptPubKey, solutions);
     CScript next_script = txout.scriptPubKey;
 
     if (script_type == TX_SCRIPTHASH && !stack.script.empty() &&
         !stack.script.back().empty()) {
         // Get the redeemScript
         CScript redeem_script(stack.script.back().begin(),
                               stack.script.back().end());
         data.redeem_script = redeem_script;
         next_script = std::move(redeem_script);
 
         // Get redeemScript type
         script_type = Solver(next_script, solutions);
         stack.script.pop_back();
     }
     if (script_type == TX_MULTISIG && !stack.script.empty()) {
         // Build a map of pubkey -> signature by matching sigs to pubkeys:
         assert(solutions.size() > 1);
         unsigned int num_pubkeys = solutions.size() - 2;
         unsigned int last_success_key = 0;
         for (const valtype &sig : stack.script) {
             for (unsigned int i = last_success_key; i < num_pubkeys; ++i) {
                 const valtype &pubkey = solutions[i + 1];
                 // We either have a signature for this pubkey, or we have found
                 // a signature and it is valid
                 if (data.signatures.count(CPubKey(pubkey).GetID()) ||
                     extractor_checker.CheckSig(sig, pubkey, next_script,
                                                STANDARD_SCRIPT_VERIFY_FLAGS)) {
                     last_success_key = i + 1;
                     break;
                 }
             }
         }
     }
 
     return data;
 }
 
 void UpdateInput(CTxIn &input, const SignatureData &data) {
     input.scriptSig = data.scriptSig;
 }
 
 void SignatureData::MergeSignatureData(SignatureData sigdata) {
     if (complete) {
         return;
     }
     if (sigdata.complete) {
         *this = std::move(sigdata);
         return;
     }
     if (redeem_script.empty() && !sigdata.redeem_script.empty()) {
         redeem_script = sigdata.redeem_script;
     }
     signatures.insert(std::make_move_iterator(sigdata.signatures.begin()),
                       std::make_move_iterator(sigdata.signatures.end()));
 }
 
 bool SignSignature(const SigningProvider &provider, const CScript &fromPubKey,
                    CMutableTransaction &txTo, unsigned int nIn,
                    const Amount amount, SigHashType sigHashType) {
     assert(nIn < txTo.vin.size());
 
     MutableTransactionSignatureCreator creator(&txTo, nIn, amount, sigHashType);
 
     SignatureData sigdata;
     bool ret = ProduceSignature(provider, creator, fromPubKey, sigdata);
     UpdateInput(txTo.vin.at(nIn), sigdata);
     return ret;
 }
 
 bool SignSignature(const SigningProvider &provider, const CTransaction &txFrom,
                    CMutableTransaction &txTo, unsigned int nIn,
                    SigHashType sigHashType) {
     assert(nIn < txTo.vin.size());
     CTxIn &txin = txTo.vin[nIn];
     assert(txin.prevout.GetN() < txFrom.vout.size());
     const CTxOut &txout = txFrom.vout[txin.prevout.GetN()];
 
     return SignSignature(provider, txout.scriptPubKey, txTo, nIn, txout.nValue,
                          sigHashType);
 }
 
 namespace {
 /** Dummy signature checker which accepts all signatures. */
 class DummySignatureChecker final : public BaseSignatureChecker {
 public:
     DummySignatureChecker() {}
     bool CheckSig(const std::vector<uint8_t> &scriptSig,
                   const std::vector<uint8_t> &vchPubKey,
                   const CScript &scriptCode, uint32_t flags) const override {
         return true;
     }
 };
 const DummySignatureChecker DUMMY_CHECKER;
 
 class DummySignatureCreator final : public BaseSignatureCreator {
 private:
     char m_r_len = 32;
     char m_s_len = 32;
 
 public:
     DummySignatureCreator(char r_len, char s_len)
         : m_r_len(r_len), m_s_len(s_len) {}
     const BaseSignatureChecker &Checker() const override {
         return DUMMY_CHECKER;
     }
     bool CreateSig(const SigningProvider &provider,
                    std::vector<uint8_t> &vchSig, const CKeyID &keyid,
                    const CScript &scriptCode) const override {
         // Create a dummy signature that is a valid DER-encoding
         vchSig.assign(m_r_len + m_s_len + 7, '\000');
         vchSig[0] = 0x30;
         vchSig[1] = m_r_len + m_s_len + 4;
         vchSig[2] = 0x02;
         vchSig[3] = m_r_len;
         vchSig[4] = 0x01;
         vchSig[4 + m_r_len] = 0x02;
         vchSig[5 + m_r_len] = m_s_len;
         vchSig[6 + m_r_len] = 0x01;
         vchSig[6 + m_r_len + m_s_len] = SIGHASH_ALL | SIGHASH_FORKID;
         return true;
     }
 };
 
 template <typename M, typename K, typename V>
 bool LookupHelper(const M &map, const K &key, V &value) {
     auto it = map.find(key);
     if (it != map.end()) {
         value = it->second;
         return true;
     }
     return false;
 }
 
 } // namespace
 
 const BaseSignatureCreator &DUMMY_SIGNATURE_CREATOR =
     DummySignatureCreator(32, 32);
 const BaseSignatureCreator &DUMMY_MAXIMUM_SIGNATURE_CREATOR =
     DummySignatureCreator(33, 32);
 const SigningProvider &DUMMY_SIGNING_PROVIDER = SigningProvider();
 
 bool HidingSigningProvider::GetCScript(const CScriptID &scriptid,
                                        CScript &script) const {
     return m_provider->GetCScript(scriptid, script);
 }
 
 bool HidingSigningProvider::GetPubKey(const CKeyID &keyid,
                                       CPubKey &pubkey) const {
     return m_provider->GetPubKey(keyid, pubkey);
 }
 
 bool HidingSigningProvider::GetKey(const CKeyID &keyid, CKey &key) const {
     if (m_hide_secret) {
         return false;
     }
     return m_provider->GetKey(keyid, key);
 }
 
 bool HidingSigningProvider::GetKeyOrigin(const CKeyID &keyid,
                                          KeyOriginInfo &info) const {
     if (m_hide_origin) {
         return false;
     }
     return m_provider->GetKeyOrigin(keyid, info);
 }
 
 bool FlatSigningProvider::GetCScript(const CScriptID &scriptid,
                                      CScript &script) const {
     return LookupHelper(scripts, scriptid, script);
 }
 bool FlatSigningProvider::GetPubKey(const CKeyID &keyid,
                                     CPubKey &pubkey) const {
     return LookupHelper(pubkeys, keyid, pubkey);
 }
 bool FlatSigningProvider::GetKey(const CKeyID &keyid, CKey &key) const {
     return LookupHelper(keys, keyid, key);
 }
 
 FlatSigningProvider Merge(const FlatSigningProvider &a,
                           const FlatSigningProvider &b) {
     FlatSigningProvider ret;
     ret.scripts = a.scripts;
     ret.scripts.insert(b.scripts.begin(), b.scripts.end());
     ret.pubkeys = a.pubkeys;
     ret.pubkeys.insert(b.pubkeys.begin(), b.pubkeys.end());
     ret.keys = a.keys;
     ret.keys.insert(b.keys.begin(), b.keys.end());
     return ret;
 }
 
 bool IsSolvable(const SigningProvider &provider, const CScript &script) {
     // This check is to make sure that the script we created can actually be
     // solved for and signed by us if we were to have the private keys. This is
     // just to make sure that the script is valid and that, if found in a
     // transaction, we would still accept and relay that transaction.
     SignatureData sigs;
     if (ProduceSignature(provider, DUMMY_SIGNATURE_CREATOR, script, sigs)) {
         // VerifyScript check is just defensive, and should never fail.
         bool verified =
             VerifyScript(sigs.scriptSig, script, STANDARD_SCRIPT_VERIFY_FLAGS,
                          DUMMY_CHECKER);
         assert(verified);
         return true;
     }
     return false;
 }
diff --git a/test/functional/rpc_psbt.py b/test/functional/rpc_psbt.py
index fb9dd0190..67fd269f2 100755
--- a/test/functional/rpc_psbt.py
+++ b/test/functional/rpc_psbt.py
@@ -1,229 +1,235 @@
 #!/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 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)
         self.nodes[0].generate(6)
         self.sync_all()
         vout1 = find_output(self.nodes[1], txid1, 13)
         vout2 = find_output(self.nodes[2], txid2, 13)
 
         # 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'])
+
 
 if __name__ == '__main__':
     PSBTTest().main()