diff --git a/src/psbt.cpp b/src/psbt.cpp
index 3b5e74314..0886b3458 100644
--- a/src/psbt.cpp
+++ b/src/psbt.cpp
@@ -1,342 +1,321 @@
 // Copyright (c) 2009-2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <psbt.h>
 
 #include <util/strencodings.h>
 
 PartiallySignedTransaction::PartiallySignedTransaction(
     const 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(const PSBTInput &input) {
     return !input.final_script_sig.empty();
 }
 
 void UpdatePSBTOutput(const SigningProvider &provider,
                       PartiallySignedTransaction &psbt, int index) {
     const CTxOut &out = psbt.tx->vout.at(index);
     PSBTOutput &psbt_out = psbt.outputs.at(index);
 
     // Fill a SignatureData with output info
     SignatureData sigdata;
     psbt_out.FillSignatureData(sigdata);
 
     // Construct a would-be spend of this output, to update sigdata with.
     // Note that ProduceSignature is used to fill in metadata (not actual
     // signatures), so provider does not need to provide any private keys (it
     // can be a HidingSigningProvider).
     MutableTransactionSignatureCreator creator(
         psbt.tx ? &psbt.tx.value() : nullptr, /* index */ 0, out.nValue,
         SigHashType().withForkId());
     ProduceSignature(provider, creator, out.scriptPubKey, sigdata);
 
     // Put redeem_script and key paths, into PSBTOutput.
     psbt_out.FromSignatureData(sigdata);
 }
 
 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(const PSBTRole role) {
     switch (role) {
         case PSBTRole::CREATOR:
             return "creator";
         case PSBTRole::UPDATER:
             return "updater";
         case PSBTRole::SIGNER:
             return "signer";
         case PSBTRole::FINALIZER:
             return "finalizer";
         case PSBTRole::EXTRACTOR:
             return "extractor";
             // no default case, so the compiler can warn about missing cases
     }
     assert(false);
 }
 
 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 e25de70ea..205b46a2b 100644
--- a/src/psbt.h
+++ b/src/psbt.h
@@ -1,588 +1,581 @@
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_PSBT_H
 #define BITCOIN_PSBT_H
 
 #include <attributes.h>
 #include <node/transaction.h>
 #include <primitives/transaction.h>
 #include <pubkey.h>
 #include <script/sign.h>
 #include <script/signingprovider.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;
 
 // BIP 174 does not specify a maximum file size, but we set a limit anyway
 // to prevent reading a stream indefinitely and running out of memory.
 const std::streamsize MAX_FILE_SIZE_PSBT = 100000000; // 100 MiB
 
 /** 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) {
         // Used for duplicate key detection
         std::set<std::vector<uint8_t>> key_lookup;
 
         // Read loop
         bool found_sep = false;
         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()) {
                 found_sep = true;
                 break;
             }
 
             // First byte of key is the type
             uint8_t type = key[0];
 
             // Do stuff based on type
             switch (type) {
                 case PSBT_IN_UTXO:
                     if (!key_lookup.emplace(key).second) {
                         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::SIZE + 1 &&
                         key.size() != CPubKey::COMPRESSED_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 (!key_lookup.emplace(key).second) {
                         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 (!key_lookup.emplace(key).second) {
                         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 (!key_lookup.emplace(key).second) {
                         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;
             }
         }
         if (!found_sep) {
             throw std::ios_base::failure(
                 "Separator is missing at the end of an input map");
         }
     }
 
     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) {
         // Used for duplicate key detection
         std::set<std::vector<uint8_t>> key_lookup;
 
         // Read loop
         bool found_sep = false;
         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()) {
                 found_sep = true;
                 break;
             }
 
             // First byte of key is the type
             uint8_t type = key[0];
 
             // Do stuff based on type
             switch (type) {
                 case PSBT_OUT_REDEEMSCRIPT: {
                     if (!key_lookup.emplace(key).second) {
                         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;
                 }
             }
         }
 
         if (!found_sep) {
             throw std::ios_base::failure(
                 "Separator is missing at the end of an output map");
         }
     }
 
     template <typename Stream> PSBTOutput(deserialize_type, Stream &s) {
         Unserialize(s);
     }
 };
 
 /**
  * A version of CTransaction with the PSBT format.
  */
 struct PartiallySignedTransaction {
     std::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() {}
     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");
         }
 
         // Used for duplicate key detection
         std::set<std::vector<uint8_t>> key_lookup;
 
         // Read global data
         bool found_sep = false;
         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()) {
                 found_sep = true;
                 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 (!key_lookup.emplace(key).second) {
                         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));
                 }
             }
         }
 
         if (!found_sep) {
             throw std::ios_base::failure(
                 "Separator is missing at the end of the global map");
         }
 
         // 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 {
     CREATOR,
     UPDATER,
     SIGNER,
     FINALIZER,
     EXTRACTOR,
 };
 
 std::string PSBTRoleName(PSBTRole role);
 
 /** Checks whether a PSBTInput is already signed. */
 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);
 
 /**
  * Updates a PSBTOutput with information from provider.
  *
  * This fills in the redeem_script, witness_script, and hd_keypaths where
  * possible.
  */
 void UpdatePSBTOutput(const SigningProvider &provider,
                       PartiallySignedTransaction &psbt, int index);
 
 /**
  * Finalizes a PSBT if possible, combining partial signatures.
  *
  * @param[in,out] psbtx 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 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);
 
 //! 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/test/fuzz/psbt.cpp b/src/test/fuzz/psbt.cpp
index dea6a8871..96364f42c 100644
--- a/src/test/fuzz/psbt.cpp
+++ b/src/test/fuzz/psbt.cpp
@@ -1,76 +1,74 @@
 // Copyright (c) 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.
 
 #include <test/fuzz/fuzz.h>
 
 #include <node/psbt.h>
 #include <psbt.h>
 #include <pubkey.h>
 #include <script/script.h>
 #include <streams.h>
 #include <version.h>
 
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <vector>
 
 void initialize() {
     static const ECCVerifyHandle verify_handle;
 }
 
 void test_one_input(const std::vector<uint8_t> &buffer) {
     PartiallySignedTransaction psbt_mut;
     const std::string raw_psbt{buffer.begin(), buffer.end()};
     std::string error;
     if (!DecodeRawPSBT(psbt_mut, raw_psbt, error)) {
         return;
     }
     const PartiallySignedTransaction psbt = psbt_mut;
 
     const PSBTAnalysis analysis = AnalyzePSBT(psbt);
     (void)PSBTRoleName(analysis.next);
     for (const PSBTInputAnalysis &input_analysis : analysis.inputs) {
         (void)PSBTRoleName(input_analysis.next);
     }
 
     (void)psbt.IsNull();
-    (void)psbt.IsSane();
 
     std::optional<CMutableTransaction> tx = psbt.tx;
     if (tx) {
         const CMutableTransaction &mtx = *tx;
         const PartiallySignedTransaction psbt_from_tx{mtx};
     }
 
     for (const PSBTInput &input : psbt.inputs) {
         (void)PSBTInputSigned(input);
         (void)input.IsNull();
-        (void)input.IsSane();
     }
 
     for (const PSBTOutput &output : psbt.outputs) {
         (void)output.IsNull();
     }
 
     for (size_t i = 0; i < psbt.tx->vin.size(); ++i) {
         CTxOut tx_out;
         if (psbt.GetInputUTXO(tx_out, i)) {
             (void)tx_out.IsNull();
             (void)tx_out.ToString();
         }
     }
 
     psbt_mut = psbt;
     (void)FinalizePSBT(psbt_mut);
 
     psbt_mut = psbt;
     CMutableTransaction result;
     if (FinalizeAndExtractPSBT(psbt_mut, result)) {
         const PartiallySignedTransaction psbt_from_tx{result};
     }
 
     psbt_mut = psbt;
     (void)psbt_mut.Merge(psbt);
 }
diff --git a/src/wallet/scriptpubkeyman.cpp b/src/wallet/scriptpubkeyman.cpp
index cabb8ff75..cb4d0f934 100644
--- a/src/wallet/scriptpubkeyman.cpp
+++ b/src/wallet/scriptpubkeyman.cpp
@@ -1,2269 +1,2257 @@
 // Copyright (c) 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.
 
 #include <chainparams.h>
 #include <config.h>
 #include <key_io.h>
 #include <outputtype.h>
 #include <script/descriptor.h>
 #include <script/sign.h>
 #include <util/bip32.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/translation.h>
 #include <wallet/scriptpubkeyman.h>
 
 bool LegacyScriptPubKeyMan::GetNewDestination(const OutputType type,
                                               CTxDestination &dest,
                                               std::string &error) {
     LOCK(cs_KeyStore);
     error.clear();
 
     // Generate a new key that is added to wallet
     CPubKey new_key;
     if (!GetKeyFromPool(new_key, type)) {
         error = _("Error: Keypool ran out, please call keypoolrefill first")
                     .translated;
         return false;
     }
     LearnRelatedScripts(new_key, type);
     dest = GetDestinationForKey(new_key, type);
     return true;
 }
 
 typedef std::vector<uint8_t> valtype;
 
 namespace {
 
 /**
  * This is an enum that tracks the execution context of a script, similar to
  * SigVersion in script/interpreter. It is separate however because we want to
  * distinguish between top-level scriptPubKey execution and P2SH redeemScript
  * execution (a distinction that has no impact on consensus rules).
  */
 enum class IsMineSigVersion {
     TOP = 0,  //! scriptPubKey execution
     P2SH = 1, //! P2SH redeemScript
 };
 
 /**
  * This is an internal representation of isminetype + invalidity.
  * Its order is significant, as we return the max of all explored
  * possibilities.
  */
 enum class IsMineResult {
     NO = 0,         //! Not ours
     WATCH_ONLY = 1, //! Included in watch-only balance
     SPENDABLE = 2,  //! Included in all balances
     INVALID = 3,    //! Not spendable by anyone (P2SH inside P2SH)
 };
 
 bool HaveKeys(const std::vector<valtype> &pubkeys,
               const LegacyScriptPubKeyMan &keystore) {
     for (const valtype &pubkey : pubkeys) {
         CKeyID keyID = CPubKey(pubkey).GetID();
         if (!keystore.HaveKey(keyID)) {
             return false;
         }
     }
     return true;
 }
 
 //! Recursively solve script and return spendable/watchonly/invalid status.
 //!
 //! @param keystore            legacy key and script store
 //! @param script              script to solve
 //! @param sigversion          script type (top-level / redeemscript /
 //! witnessscript)
 //! @param recurse_scripthash  whether to recurse into nested p2sh and p2wsh
 //!                            scripts or simply treat any script that has been
 //!                            stored in the keystore as spendable
 IsMineResult IsMineInner(const LegacyScriptPubKeyMan &keystore,
                          const CScript &scriptPubKey,
                          IsMineSigVersion sigversion,
                          bool recurse_scripthash = true) {
     IsMineResult ret = IsMineResult::NO;
 
     std::vector<valtype> vSolutions;
     TxoutType whichType = Solver(scriptPubKey, vSolutions);
 
     CKeyID keyID;
     switch (whichType) {
         case TxoutType::NONSTANDARD:
         case TxoutType::NULL_DATA:
             break;
         case TxoutType::PUBKEY:
             keyID = CPubKey(vSolutions[0]).GetID();
             if (keystore.HaveKey(keyID)) {
                 ret = std::max(ret, IsMineResult::SPENDABLE);
             }
             break;
         case TxoutType::PUBKEYHASH:
             keyID = CKeyID(uint160(vSolutions[0]));
             if (keystore.HaveKey(keyID)) {
                 ret = std::max(ret, IsMineResult::SPENDABLE);
             }
             break;
         case TxoutType::SCRIPTHASH: {
             if (sigversion != IsMineSigVersion::TOP) {
                 // P2SH inside P2SH is invalid.
                 return IsMineResult::INVALID;
             }
             CScriptID scriptID = CScriptID(uint160(vSolutions[0]));
             CScript subscript;
             if (keystore.GetCScript(scriptID, subscript)) {
                 ret = std::max(ret, recurse_scripthash
                                         ? IsMineInner(keystore, subscript,
                                                       IsMineSigVersion::P2SH)
                                         : IsMineResult::SPENDABLE);
             }
             break;
         }
         case TxoutType::MULTISIG: {
             // Never treat bare multisig outputs as ours (they can still be made
             // watchonly-though)
             if (sigversion == IsMineSigVersion::TOP) {
                 break;
             }
 
             // Only consider transactions "mine" if we own ALL the keys
             // involved. Multi-signature transactions that are partially owned
             // (somebody else has a key that can spend them) enable
             // spend-out-from-under-you attacks, especially in shared-wallet
             // situations.
             std::vector<valtype> keys(vSolutions.begin() + 1,
                                       vSolutions.begin() + vSolutions.size() -
                                           1);
             if (HaveKeys(keys, keystore)) {
                 ret = std::max(ret, IsMineResult::SPENDABLE);
             }
             break;
         }
     }
 
     if (ret == IsMineResult::NO && keystore.HaveWatchOnly(scriptPubKey)) {
         ret = std::max(ret, IsMineResult::WATCH_ONLY);
     }
     return ret;
 }
 
 } // namespace
 
 isminetype LegacyScriptPubKeyMan::IsMine(const CScript &script) const {
     switch (IsMineInner(*this, script, IsMineSigVersion::TOP)) {
         case IsMineResult::INVALID:
         case IsMineResult::NO:
             return ISMINE_NO;
         case IsMineResult::WATCH_ONLY:
             return ISMINE_WATCH_ONLY;
         case IsMineResult::SPENDABLE:
             return ISMINE_SPENDABLE;
     }
     assert(false);
 }
 
 bool LegacyScriptPubKeyMan::CheckDecryptionKey(
     const CKeyingMaterial &master_key, bool accept_no_keys) {
     {
         LOCK(cs_KeyStore);
         assert(mapKeys.empty());
 
         // Always pass when there are no encrypted keys
         bool keyPass = mapCryptedKeys.empty();
         bool keyFail = false;
         CryptedKeyMap::const_iterator mi = mapCryptedKeys.begin();
         for (; mi != mapCryptedKeys.end(); ++mi) {
             const CPubKey &vchPubKey = (*mi).second.first;
             const std::vector<uint8_t> &vchCryptedSecret = (*mi).second.second;
             CKey key;
             if (!DecryptKey(master_key, vchCryptedSecret, vchPubKey, key)) {
                 keyFail = true;
                 break;
             }
             keyPass = true;
             if (fDecryptionThoroughlyChecked) {
                 break;
             }
         }
         if (keyPass && keyFail) {
             LogPrintf("The wallet is probably corrupted: Some keys decrypt but "
                       "not all.\n");
             throw std::runtime_error(
                 "Error unlocking wallet: some keys decrypt but not all. Your "
                 "wallet file may be corrupt.");
         }
         if (keyFail || (!keyPass && !accept_no_keys)) {
             return false;
         }
         fDecryptionThoroughlyChecked = true;
     }
     return true;
 }
 
 bool LegacyScriptPubKeyMan::Encrypt(const CKeyingMaterial &master_key,
                                     WalletBatch *batch) {
     LOCK(cs_KeyStore);
     encrypted_batch = batch;
     if (!mapCryptedKeys.empty()) {
         encrypted_batch = nullptr;
         return false;
     }
 
     KeyMap keys_to_encrypt;
     // Clear mapKeys so AddCryptedKeyInner will succeed.
     keys_to_encrypt.swap(mapKeys);
     for (const KeyMap::value_type &mKey : keys_to_encrypt) {
         const CKey &key = mKey.second;
         CPubKey vchPubKey = key.GetPubKey();
         CKeyingMaterial vchSecret(key.begin(), key.end());
         std::vector<uint8_t> vchCryptedSecret;
         if (!EncryptSecret(master_key, vchSecret, vchPubKey.GetHash(),
                            vchCryptedSecret)) {
             encrypted_batch = nullptr;
             return false;
         }
         if (!AddCryptedKey(vchPubKey, vchCryptedSecret)) {
             encrypted_batch = nullptr;
             return false;
         }
     }
     encrypted_batch = nullptr;
     return true;
 }
 
 bool LegacyScriptPubKeyMan::GetReservedDestination(const OutputType type,
                                                    bool internal,
                                                    CTxDestination &address,
                                                    int64_t &index,
                                                    CKeyPool &keypool) {
     LOCK(cs_KeyStore);
     if (!CanGetAddresses(internal)) {
         return false;
     }
 
     if (!ReserveKeyFromKeyPool(index, keypool, internal)) {
         return false;
     }
     address = GetDestinationForKey(keypool.vchPubKey, type);
     return true;
 }
 
 void LegacyScriptPubKeyMan::MarkUnusedAddresses(const CScript &script) {
     LOCK(cs_KeyStore);
     // extract addresses and check if they match with an unused keypool key
     for (const auto &keyid : GetAffectedKeys(script, *this)) {
         std::map<CKeyID, int64_t>::const_iterator mi =
             m_pool_key_to_index.find(keyid);
         if (mi != m_pool_key_to_index.end()) {
             WalletLogPrintf("%s: Detected a used keypool key, mark all keypool "
                             "key up to this key as used\n",
                             __func__);
             MarkReserveKeysAsUsed(mi->second);
 
             if (!TopUp()) {
                 WalletLogPrintf(
                     "%s: Topping up keypool failed (locked wallet)\n",
                     __func__);
             }
         }
     }
 }
 
 void LegacyScriptPubKeyMan::UpgradeKeyMetadata() {
     LOCK(cs_KeyStore);
     if (m_storage.IsLocked() ||
         m_storage.IsWalletFlagSet(WALLET_FLAG_KEY_ORIGIN_METADATA)) {
         return;
     }
 
     auto batch = std::make_unique<WalletBatch>(m_storage.GetDatabase());
     for (auto &meta_pair : mapKeyMetadata) {
         CKeyMetadata &meta = meta_pair.second;
         // If the hdKeypath is "s", that's the seed and it doesn't have a key
         // origin
         if (!meta.hd_seed_id.IsNull() && !meta.has_key_origin &&
             meta.hdKeypath != "s") {
             CKey key;
             GetKey(meta.hd_seed_id, key);
             CExtKey masterKey;
             masterKey.SetSeed(key.begin(), key.size());
             // Add to map
             CKeyID master_id = masterKey.key.GetPubKey().GetID();
             std::copy(master_id.begin(), master_id.begin() + 4,
                       meta.key_origin.fingerprint);
             if (!ParseHDKeypath(meta.hdKeypath, meta.key_origin.path)) {
                 throw std::runtime_error("Invalid stored hdKeypath");
             }
             meta.has_key_origin = true;
             if (meta.nVersion < CKeyMetadata::VERSION_WITH_KEY_ORIGIN) {
                 meta.nVersion = CKeyMetadata::VERSION_WITH_KEY_ORIGIN;
             }
 
             // Write meta to wallet
             CPubKey pubkey;
             if (GetPubKey(meta_pair.first, pubkey)) {
                 batch->WriteKeyMetadata(meta, pubkey, true);
             }
         }
     }
 }
 
 bool LegacyScriptPubKeyMan::SetupGeneration(bool force) {
     if ((CanGenerateKeys() && !force) || m_storage.IsLocked()) {
         return false;
     }
 
     SetHDSeed(GenerateNewSeed());
     if (!NewKeyPool()) {
         return false;
     }
     return true;
 }
 
 bool LegacyScriptPubKeyMan::IsHDEnabled() const {
     return !hdChain.seed_id.IsNull();
 }
 
 bool LegacyScriptPubKeyMan::CanGetAddresses(bool internal) const {
     LOCK(cs_KeyStore);
     // Check if the keypool has keys
     bool keypool_has_keys;
     if (internal && m_storage.CanSupportFeature(FEATURE_HD_SPLIT)) {
         keypool_has_keys = setInternalKeyPool.size() > 0;
     } else {
         keypool_has_keys = KeypoolCountExternalKeys() > 0;
     }
     // If the keypool doesn't have keys, check if we can generate them
     if (!keypool_has_keys) {
         return CanGenerateKeys();
     }
     return keypool_has_keys;
 }
 
 bool LegacyScriptPubKeyMan::Upgrade(int prev_version, bilingual_str &error) {
     LOCK(cs_KeyStore);
     bool hd_upgrade = false;
     bool split_upgrade = false;
     if (m_storage.CanSupportFeature(FEATURE_HD) && !IsHDEnabled()) {
         WalletLogPrintf("Upgrading wallet to HD\n");
         m_storage.SetMinVersion(FEATURE_HD);
 
         // generate a new master key
         CPubKey masterPubKey = GenerateNewSeed();
         SetHDSeed(masterPubKey);
         hd_upgrade = true;
     }
     // Upgrade to HD chain split if necessary
     if (m_storage.CanSupportFeature(FEATURE_HD_SPLIT) &&
         CHDChain::VERSION_HD_CHAIN_SPLIT) {
         WalletLogPrintf("Upgrading wallet to use HD chain split\n");
         m_storage.SetMinVersion(FEATURE_PRE_SPLIT_KEYPOOL);
         split_upgrade = FEATURE_HD_SPLIT > prev_version;
     }
     // Mark all keys currently in the keypool as pre-split
     if (split_upgrade) {
         MarkPreSplitKeys();
     }
     // Regenerate the keypool if upgraded to HD
     if (hd_upgrade) {
         if (!TopUp()) {
             error = _("Unable to generate keys");
             return false;
         }
     }
     return true;
 }
 
 bool LegacyScriptPubKeyMan::HavePrivateKeys() const {
     LOCK(cs_KeyStore);
     return !mapKeys.empty() || !mapCryptedKeys.empty();
 }
 
 void LegacyScriptPubKeyMan::RewriteDB() {
     LOCK(cs_KeyStore);
     setInternalKeyPool.clear();
     setExternalKeyPool.clear();
     m_pool_key_to_index.clear();
     // Note: can't top-up keypool here, because wallet is locked.
     // User will be prompted to unlock wallet the next operation
     // that requires a new key.
 }
 
 static int64_t GetOldestKeyTimeInPool(const std::set<int64_t> &setKeyPool,
                                       WalletBatch &batch) {
     if (setKeyPool.empty()) {
         return GetTime();
     }
 
     CKeyPool keypool;
     int64_t nIndex = *(setKeyPool.begin());
     if (!batch.ReadPool(nIndex, keypool)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": read oldest key in keypool failed");
     }
 
     assert(keypool.vchPubKey.IsValid());
     return keypool.nTime;
 }
 
 int64_t LegacyScriptPubKeyMan::GetOldestKeyPoolTime() const {
     LOCK(cs_KeyStore);
 
     WalletBatch batch(m_storage.GetDatabase());
 
     // load oldest key from keypool, get time and return
     int64_t oldestKey = GetOldestKeyTimeInPool(setExternalKeyPool, batch);
     if (IsHDEnabled() && m_storage.CanSupportFeature(FEATURE_HD_SPLIT)) {
         oldestKey = std::max(GetOldestKeyTimeInPool(setInternalKeyPool, batch),
                              oldestKey);
         if (!set_pre_split_keypool.empty()) {
             oldestKey =
                 std::max(GetOldestKeyTimeInPool(set_pre_split_keypool, batch),
                          oldestKey);
         }
     }
 
     return oldestKey;
 }
 
 size_t LegacyScriptPubKeyMan::KeypoolCountExternalKeys() const {
     LOCK(cs_KeyStore);
     return setExternalKeyPool.size() + set_pre_split_keypool.size();
 }
 
 unsigned int LegacyScriptPubKeyMan::GetKeyPoolSize() const {
     LOCK(cs_KeyStore);
     return setInternalKeyPool.size() + setExternalKeyPool.size() +
            set_pre_split_keypool.size();
 }
 
 int64_t LegacyScriptPubKeyMan::GetTimeFirstKey() const {
     LOCK(cs_KeyStore);
     return nTimeFirstKey;
 }
 
 std::unique_ptr<SigningProvider>
 LegacyScriptPubKeyMan::GetSolvingProvider(const CScript &script) const {
     return std::make_unique<LegacySigningProvider>(*this);
 }
 
 bool LegacyScriptPubKeyMan::CanProvide(const CScript &script,
                                        SignatureData &sigdata) {
     IsMineResult ismine = IsMineInner(*this, script, IsMineSigVersion::TOP,
                                       /* recurse_scripthash= */ false);
     if (ismine == IsMineResult::SPENDABLE ||
         ismine == IsMineResult::WATCH_ONLY) {
         // If ismine, it means we recognize keys or script ids in the script, or
         // are watching the script itself, and we can at least provide metadata
         // or solving information, even if not able to sign fully.
         return true;
     }
     // If, given the stuff in sigdata, we could make a valid sigature, then
     // we can provide for this script
     ProduceSignature(*this, DUMMY_SIGNATURE_CREATOR, script, sigdata);
     if (!sigdata.signatures.empty()) {
         // If we could make signatures, make sure we have a private key to
         // actually make a signature
         bool has_privkeys = false;
         for (const auto &key_sig_pair : sigdata.signatures) {
             has_privkeys |= HaveKey(key_sig_pair.first);
         }
         return has_privkeys;
     }
     return false;
 }
 
 bool LegacyScriptPubKeyMan::SignTransaction(
     CMutableTransaction &tx, const std::map<COutPoint, Coin> &coins,
     SigHashType sighash, std::map<int, std::string> &input_errors) const {
     return ::SignTransaction(tx, this, coins, sighash, input_errors);
 }
 
 SigningResult LegacyScriptPubKeyMan::SignMessage(const std::string &message,
                                                  const PKHash &pkhash,
                                                  std::string &str_sig) const {
     CKeyID key_id(pkhash);
     CKey key;
     if (!GetKey(key_id, key)) {
         return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
     }
 
     if (MessageSign(key, message, str_sig)) {
         return SigningResult::OK;
     }
     return SigningResult::SIGNING_FAILED;
 }
 
 TransactionError
 LegacyScriptPubKeyMan::FillPSBT(PartiallySignedTransaction &psbtx,
                                 SigHashType sighash_type, bool sign,
                                 bool bip32derivs) const {
     for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
         PSBTInput &input = psbtx.inputs.at(i);
 
         if (PSBTInputSigned(input)) {
             continue;
         }
 
-        // Verify input looks sane. This will check that we have at most one
-        // uxto, witness or non-witness.
-        if (!input.IsSane()) {
-            return TransactionError::INVALID_PSBT;
-        }
-
         // Get the Sighash type
         if (sign && input.sighash_type.getRawSigHashType() > 0 &&
             input.sighash_type != sighash_type) {
             return TransactionError::SIGHASH_MISMATCH;
         }
 
         if (input.utxo.IsNull()) {
             // There's no UTXO so we can just skip this now
             continue;
         }
         SignatureData sigdata;
         input.FillSignatureData(sigdata);
         SignPSBTInput(HidingSigningProvider(this, !sign, !bip32derivs), psbtx,
                       i, sighash_type);
     }
 
     // Fill in the bip32 keypaths and redeemscripts for the outputs so that
     // hardware wallets can identify change
     for (size_t i = 0; i < psbtx.tx->vout.size(); ++i) {
         UpdatePSBTOutput(HidingSigningProvider(this, true, !bip32derivs), psbtx,
                          i);
     }
 
     return TransactionError::OK;
 }
 
 std::unique_ptr<CKeyMetadata>
 LegacyScriptPubKeyMan::GetMetadata(const CTxDestination &dest) const {
     LOCK(cs_KeyStore);
 
     CKeyID key_id = GetKeyForDestination(*this, dest);
     if (!key_id.IsNull()) {
         auto it = mapKeyMetadata.find(key_id);
         if (it != mapKeyMetadata.end()) {
             return std::make_unique<CKeyMetadata>(it->second);
         }
     }
 
     CScript scriptPubKey = GetScriptForDestination(dest);
     auto it = m_script_metadata.find(CScriptID(scriptPubKey));
     if (it != m_script_metadata.end()) {
         return std::make_unique<CKeyMetadata>(it->second);
     }
 
     return nullptr;
 }
 
 uint256 LegacyScriptPubKeyMan::GetID() const {
     return UINT256_ONE();
 }
 
 /**
  * Update wallet first key creation time. This should be called whenever keys
  * are added to the wallet, with the oldest key creation time.
  */
 void LegacyScriptPubKeyMan::UpdateTimeFirstKey(int64_t nCreateTime) {
     AssertLockHeld(cs_KeyStore);
     if (nCreateTime <= 1) {
         // Cannot determine birthday information, so set the wallet birthday to
         // the beginning of time.
         nTimeFirstKey = 1;
     } else if (!nTimeFirstKey || nCreateTime < nTimeFirstKey) {
         nTimeFirstKey = nCreateTime;
     }
 }
 
 bool LegacyScriptPubKeyMan::LoadKey(const CKey &key, const CPubKey &pubkey) {
     return AddKeyPubKeyInner(key, pubkey);
 }
 
 bool LegacyScriptPubKeyMan::AddKeyPubKey(const CKey &secret,
                                          const CPubKey &pubkey) {
     LOCK(cs_KeyStore);
     WalletBatch batch(m_storage.GetDatabase());
     return LegacyScriptPubKeyMan::AddKeyPubKeyWithDB(batch, secret, pubkey);
 }
 
 bool LegacyScriptPubKeyMan::AddKeyPubKeyWithDB(WalletBatch &batch,
                                                const CKey &secret,
                                                const CPubKey &pubkey) {
     AssertLockHeld(cs_KeyStore);
 
     // Make sure we aren't adding private keys to private key disabled wallets
     assert(!m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
 
     // FillableSigningProvider has no concept of wallet databases, but calls
     // AddCryptedKey which is overridden below. To avoid flushes, the database
     // handle is tunneled through to it.
     bool needsDB = !encrypted_batch;
     if (needsDB) {
         encrypted_batch = &batch;
     }
     if (!AddKeyPubKeyInner(secret, pubkey)) {
         if (needsDB) {
             encrypted_batch = nullptr;
         }
         return false;
     }
 
     if (needsDB) {
         encrypted_batch = nullptr;
     }
 
     // Check if we need to remove from watch-only.
     CScript script;
     script = GetScriptForDestination(PKHash(pubkey));
     if (HaveWatchOnly(script)) {
         RemoveWatchOnly(script);
     }
 
     script = GetScriptForRawPubKey(pubkey);
     if (HaveWatchOnly(script)) {
         RemoveWatchOnly(script);
     }
 
     if (!m_storage.HasEncryptionKeys()) {
         return batch.WriteKey(pubkey, secret.GetPrivKey(),
                               mapKeyMetadata[pubkey.GetID()]);
     }
     m_storage.UnsetBlankWalletFlag(batch);
     return true;
 }
 
 bool LegacyScriptPubKeyMan::LoadCScript(const CScript &redeemScript) {
     /**
      * A sanity check was added in pull #3843 to avoid adding redeemScripts that
      * never can be redeemed. However, old wallets may still contain these. Do
      * not add them to the wallet and warn.
      */
     if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE) {
         std::string strAddr =
             EncodeDestination(ScriptHash(redeemScript), GetConfig());
         WalletLogPrintf("%s: Warning: This wallet contains a redeemScript "
                         "of size %i which exceeds maximum size %i thus can "
                         "never be redeemed. Do not use address %s.\n",
                         __func__, redeemScript.size(), MAX_SCRIPT_ELEMENT_SIZE,
                         strAddr);
         return true;
     }
 
     return FillableSigningProvider::AddCScript(redeemScript);
 }
 
 void LegacyScriptPubKeyMan::LoadKeyMetadata(const CKeyID &keyID,
                                             const CKeyMetadata &meta) {
     LOCK(cs_KeyStore);
     UpdateTimeFirstKey(meta.nCreateTime);
     mapKeyMetadata[keyID] = meta;
 }
 
 void LegacyScriptPubKeyMan::LoadScriptMetadata(const CScriptID &script_id,
                                                const CKeyMetadata &meta) {
     LOCK(cs_KeyStore);
     UpdateTimeFirstKey(meta.nCreateTime);
     m_script_metadata[script_id] = meta;
 }
 
 bool LegacyScriptPubKeyMan::AddKeyPubKeyInner(const CKey &key,
                                               const CPubKey &pubkey) {
     LOCK(cs_KeyStore);
     if (!m_storage.HasEncryptionKeys()) {
         return FillableSigningProvider::AddKeyPubKey(key, pubkey);
     }
 
     if (m_storage.IsLocked()) {
         return false;
     }
 
     std::vector<uint8_t> vchCryptedSecret;
     CKeyingMaterial vchSecret(key.begin(), key.end());
     if (!EncryptSecret(m_storage.GetEncryptionKey(), vchSecret,
                        pubkey.GetHash(), vchCryptedSecret)) {
         return false;
     }
 
     if (!AddCryptedKey(pubkey, vchCryptedSecret)) {
         return false;
     }
     return true;
 }
 
 bool LegacyScriptPubKeyMan::LoadCryptedKey(
     const CPubKey &vchPubKey, const std::vector<uint8_t> &vchCryptedSecret) {
     return AddCryptedKeyInner(vchPubKey, vchCryptedSecret);
 }
 
 bool LegacyScriptPubKeyMan::AddCryptedKeyInner(
     const CPubKey &vchPubKey, const std::vector<uint8_t> &vchCryptedSecret) {
     LOCK(cs_KeyStore);
     assert(mapKeys.empty());
 
     mapCryptedKeys[vchPubKey.GetID()] = make_pair(vchPubKey, vchCryptedSecret);
     return true;
 }
 
 bool LegacyScriptPubKeyMan::AddCryptedKey(
     const CPubKey &vchPubKey, const std::vector<uint8_t> &vchCryptedSecret) {
     if (!AddCryptedKeyInner(vchPubKey, vchCryptedSecret)) {
         return false;
     }
 
     LOCK(cs_KeyStore);
     if (encrypted_batch) {
         return encrypted_batch->WriteCryptedKey(
             vchPubKey, vchCryptedSecret, mapKeyMetadata[vchPubKey.GetID()]);
     }
 
     return WalletBatch(m_storage.GetDatabase())
         .WriteCryptedKey(vchPubKey, vchCryptedSecret,
                          mapKeyMetadata[vchPubKey.GetID()]);
 }
 
 bool LegacyScriptPubKeyMan::HaveWatchOnly(const CScript &dest) const {
     LOCK(cs_KeyStore);
     return setWatchOnly.count(dest) > 0;
 }
 
 bool LegacyScriptPubKeyMan::HaveWatchOnly() const {
     LOCK(cs_KeyStore);
     return (!setWatchOnly.empty());
 }
 
 static bool ExtractPubKey(const CScript &dest, CPubKey &pubKeyOut) {
     std::vector<std::vector<uint8_t>> solutions;
     return Solver(dest, solutions) == TxoutType::PUBKEY &&
            (pubKeyOut = CPubKey(solutions[0])).IsFullyValid();
 }
 
 bool LegacyScriptPubKeyMan::RemoveWatchOnly(const CScript &dest) {
     {
         LOCK(cs_KeyStore);
         setWatchOnly.erase(dest);
         CPubKey pubKey;
         if (ExtractPubKey(dest, pubKey)) {
             mapWatchKeys.erase(pubKey.GetID());
         }
     }
 
     if (!HaveWatchOnly()) {
         NotifyWatchonlyChanged(false);
     }
 
     return WalletBatch(m_storage.GetDatabase()).EraseWatchOnly(dest);
 }
 
 bool LegacyScriptPubKeyMan::LoadWatchOnly(const CScript &dest) {
     return AddWatchOnlyInMem(dest);
 }
 
 bool LegacyScriptPubKeyMan::AddWatchOnlyInMem(const CScript &dest) {
     LOCK(cs_KeyStore);
     setWatchOnly.insert(dest);
     CPubKey pubKey;
     if (ExtractPubKey(dest, pubKey)) {
         mapWatchKeys[pubKey.GetID()] = pubKey;
     }
     return true;
 }
 
 bool LegacyScriptPubKeyMan::AddWatchOnlyWithDB(WalletBatch &batch,
                                                const CScript &dest) {
     if (!AddWatchOnlyInMem(dest)) {
         return false;
     }
 
     const CKeyMetadata &meta = m_script_metadata[CScriptID(dest)];
     UpdateTimeFirstKey(meta.nCreateTime);
     NotifyWatchonlyChanged(true);
     if (batch.WriteWatchOnly(dest, meta)) {
         m_storage.UnsetBlankWalletFlag(batch);
         return true;
     }
     return false;
 }
 
 bool LegacyScriptPubKeyMan::AddWatchOnlyWithDB(WalletBatch &batch,
                                                const CScript &dest,
                                                int64_t create_time) {
     m_script_metadata[CScriptID(dest)].nCreateTime = create_time;
     return AddWatchOnlyWithDB(batch, dest);
 }
 
 bool LegacyScriptPubKeyMan::AddWatchOnly(const CScript &dest) {
     WalletBatch batch(m_storage.GetDatabase());
     return AddWatchOnlyWithDB(batch, dest);
 }
 
 bool LegacyScriptPubKeyMan::AddWatchOnly(const CScript &dest,
                                          int64_t nCreateTime) {
     m_script_metadata[CScriptID(dest)].nCreateTime = nCreateTime;
     return AddWatchOnly(dest);
 }
 
 void LegacyScriptPubKeyMan::SetHDChain(const CHDChain &chain, bool memonly) {
     LOCK(cs_KeyStore);
     if (!memonly && !WalletBatch(m_storage.GetDatabase()).WriteHDChain(chain)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing chain failed");
     }
 
     hdChain = chain;
 }
 
 bool LegacyScriptPubKeyMan::HaveKey(const CKeyID &address) const {
     LOCK(cs_KeyStore);
     if (!m_storage.HasEncryptionKeys()) {
         return FillableSigningProvider::HaveKey(address);
     }
     return mapCryptedKeys.count(address) > 0;
 }
 
 bool LegacyScriptPubKeyMan::GetKey(const CKeyID &address, CKey &keyOut) const {
     LOCK(cs_KeyStore);
     if (!m_storage.HasEncryptionKeys()) {
         return FillableSigningProvider::GetKey(address, keyOut);
     }
 
     CryptedKeyMap::const_iterator mi = mapCryptedKeys.find(address);
     if (mi != mapCryptedKeys.end()) {
         const CPubKey &vchPubKey = (*mi).second.first;
         const std::vector<uint8_t> &vchCryptedSecret = (*mi).second.second;
         return DecryptKey(m_storage.GetEncryptionKey(), vchCryptedSecret,
                           vchPubKey, keyOut);
     }
     return false;
 }
 
 bool LegacyScriptPubKeyMan::GetKeyOrigin(const CKeyID &keyID,
                                          KeyOriginInfo &info) const {
     CKeyMetadata meta;
     {
         LOCK(cs_KeyStore);
         auto it = mapKeyMetadata.find(keyID);
         if (it != mapKeyMetadata.end()) {
             meta = it->second;
         }
     }
     if (meta.has_key_origin) {
         std::copy(meta.key_origin.fingerprint, meta.key_origin.fingerprint + 4,
                   info.fingerprint);
         info.path = meta.key_origin.path;
     } else {
         // Single pubkeys get the master fingerprint of themselves
         std::copy(keyID.begin(), keyID.begin() + 4, info.fingerprint);
     }
     return true;
 }
 
 bool LegacyScriptPubKeyMan::GetWatchPubKey(const CKeyID &address,
                                            CPubKey &pubkey_out) const {
     LOCK(cs_KeyStore);
     WatchKeyMap::const_iterator it = mapWatchKeys.find(address);
     if (it != mapWatchKeys.end()) {
         pubkey_out = it->second;
         return true;
     }
     return false;
 }
 
 bool LegacyScriptPubKeyMan::GetPubKey(const CKeyID &address,
                                       CPubKey &vchPubKeyOut) const {
     LOCK(cs_KeyStore);
     if (!m_storage.HasEncryptionKeys()) {
         if (!FillableSigningProvider::GetPubKey(address, vchPubKeyOut)) {
             return GetWatchPubKey(address, vchPubKeyOut);
         }
         return true;
     }
 
     CryptedKeyMap::const_iterator mi = mapCryptedKeys.find(address);
     if (mi != mapCryptedKeys.end()) {
         vchPubKeyOut = (*mi).second.first;
         return true;
     }
 
     // Check for watch-only pubkeys
     return GetWatchPubKey(address, vchPubKeyOut);
 }
 
 CPubKey LegacyScriptPubKeyMan::GenerateNewKey(WalletBatch &batch,
                                               bool internal) {
     assert(!m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
     assert(!m_storage.IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET));
     AssertLockHeld(cs_KeyStore);
     // default to compressed public keys if we want 0.6.0 wallets
     bool fCompressed = m_storage.CanSupportFeature(FEATURE_COMPRPUBKEY);
 
     CKey secret;
 
     // Create new metadata
     int64_t nCreationTime = GetTime();
     CKeyMetadata metadata(nCreationTime);
 
     // use HD key derivation if HD was enabled during wallet creation and a seed
     // is present
     if (IsHDEnabled()) {
         DeriveNewChildKey(
             batch, metadata, secret,
             (m_storage.CanSupportFeature(FEATURE_HD_SPLIT) ? internal : false));
     } else {
         secret.MakeNewKey(fCompressed);
     }
 
     // Compressed public keys were introduced in version 0.6.0
     if (fCompressed) {
         m_storage.SetMinVersion(FEATURE_COMPRPUBKEY);
     }
 
     CPubKey pubkey = secret.GetPubKey();
     assert(secret.VerifyPubKey(pubkey));
 
     mapKeyMetadata[pubkey.GetID()] = metadata;
     UpdateTimeFirstKey(nCreationTime);
 
     if (!AddKeyPubKeyWithDB(batch, secret, pubkey)) {
         throw std::runtime_error(std::string(__func__) + ": AddKey failed");
     }
 
     return pubkey;
 }
 
 const uint32_t BIP32_HARDENED_KEY_LIMIT = 0x80000000;
 
 void LegacyScriptPubKeyMan::DeriveNewChildKey(WalletBatch &batch,
                                               CKeyMetadata &metadata,
                                               CKey &secret, bool internal) {
     // for now we use a fixed keypath scheme of m/0'/0'/k
     // seed (256bit)
     CKey seed;
     // hd master key
     CExtKey masterKey;
     // key at m/0'
     CExtKey accountKey;
     // key at m/0'/0' (external) or m/0'/1' (internal)
     CExtKey chainChildKey;
     // key at m/0'/0'/<n>'
     CExtKey childKey;
 
     // try to get the seed
     if (!GetKey(hdChain.seed_id, seed)) {
         throw std::runtime_error(std::string(__func__) + ": seed not found");
     }
 
     masterKey.SetSeed(seed.begin(), seed.size());
 
     // derive m/0'
     // use hardened derivation (child keys >= 0x80000000 are hardened after
     // bip32)
     masterKey.Derive(accountKey, BIP32_HARDENED_KEY_LIMIT);
 
     // derive m/0'/0' (external chain) OR m/0'/1' (internal chain)
     assert(internal ? m_storage.CanSupportFeature(FEATURE_HD_SPLIT) : true);
     accountKey.Derive(chainChildKey,
                       BIP32_HARDENED_KEY_LIMIT + (internal ? 1 : 0));
 
     // derive child key at next index, skip keys already known to the wallet
     do {
         // always derive hardened keys
         // childIndex | BIP32_HARDENED_KEY_LIMIT = derive childIndex in hardened
         // child-index-range
         // example: 1 | BIP32_HARDENED_KEY_LIMIT == 0x80000001 == 2147483649
         if (internal) {
             chainChildKey.Derive(childKey, hdChain.nInternalChainCounter |
                                                BIP32_HARDENED_KEY_LIMIT);
             metadata.hdKeypath =
                 "m/0'/1'/" + ToString(hdChain.nInternalChainCounter) + "'";
             metadata.key_origin.path.push_back(0 | BIP32_HARDENED_KEY_LIMIT);
             metadata.key_origin.path.push_back(1 | BIP32_HARDENED_KEY_LIMIT);
             metadata.key_origin.path.push_back(hdChain.nInternalChainCounter |
                                                BIP32_HARDENED_KEY_LIMIT);
             hdChain.nInternalChainCounter++;
         } else {
             chainChildKey.Derive(childKey, hdChain.nExternalChainCounter |
                                                BIP32_HARDENED_KEY_LIMIT);
             metadata.hdKeypath =
                 "m/0'/0'/" + ToString(hdChain.nExternalChainCounter) + "'";
             metadata.key_origin.path.push_back(0 | BIP32_HARDENED_KEY_LIMIT);
             metadata.key_origin.path.push_back(0 | BIP32_HARDENED_KEY_LIMIT);
             metadata.key_origin.path.push_back(hdChain.nExternalChainCounter |
                                                BIP32_HARDENED_KEY_LIMIT);
             hdChain.nExternalChainCounter++;
         }
     } while (HaveKey(childKey.key.GetPubKey().GetID()));
     secret = childKey.key;
     metadata.hd_seed_id = hdChain.seed_id;
     CKeyID master_id = masterKey.key.GetPubKey().GetID();
     std::copy(master_id.begin(), master_id.begin() + 4,
               metadata.key_origin.fingerprint);
     metadata.has_key_origin = true;
     // update the chain model in the database
     if (!batch.WriteHDChain(hdChain)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": Writing HD chain model failed");
     }
 }
 
 void LegacyScriptPubKeyMan::LoadKeyPool(int64_t nIndex,
                                         const CKeyPool &keypool) {
     LOCK(cs_KeyStore);
     if (keypool.m_pre_split) {
         set_pre_split_keypool.insert(nIndex);
     } else if (keypool.fInternal) {
         setInternalKeyPool.insert(nIndex);
     } else {
         setExternalKeyPool.insert(nIndex);
     }
     m_max_keypool_index = std::max(m_max_keypool_index, nIndex);
     m_pool_key_to_index[keypool.vchPubKey.GetID()] = nIndex;
 
     // If no metadata exists yet, create a default with the pool key's
     // creation time. Note that this may be overwritten by actually
     // stored metadata for that key later, which is fine.
     CKeyID keyid = keypool.vchPubKey.GetID();
     if (mapKeyMetadata.count(keyid) == 0) {
         mapKeyMetadata[keyid] = CKeyMetadata(keypool.nTime);
     }
 }
 
 bool LegacyScriptPubKeyMan::CanGenerateKeys() const {
     // A wallet can generate keys if it has an HD seed (IsHDEnabled) or it is a
     // non-HD wallet (pre FEATURE_HD)
     LOCK(cs_KeyStore);
     return IsHDEnabled() || !m_storage.CanSupportFeature(FEATURE_HD);
 }
 
 CPubKey LegacyScriptPubKeyMan::GenerateNewSeed() {
     assert(!m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
     CKey key;
     key.MakeNewKey(true);
     return DeriveNewSeed(key);
 }
 
 CPubKey LegacyScriptPubKeyMan::DeriveNewSeed(const CKey &key) {
     int64_t nCreationTime = GetTime();
     CKeyMetadata metadata(nCreationTime);
 
     // Calculate the seed
     CPubKey seed = key.GetPubKey();
     assert(key.VerifyPubKey(seed));
 
     // Set the hd keypath to "s" -> Seed, refers the seed to itself
     metadata.hdKeypath = "s";
     metadata.has_key_origin = false;
     metadata.hd_seed_id = seed.GetID();
 
     LOCK(cs_KeyStore);
 
     // mem store the metadata
     mapKeyMetadata[seed.GetID()] = metadata;
 
     // Write the key&metadata to the database
     if (!AddKeyPubKey(key, seed)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": AddKeyPubKey failed");
     }
 
     return seed;
 }
 
 void LegacyScriptPubKeyMan::SetHDSeed(const CPubKey &seed) {
     LOCK(cs_KeyStore);
 
     // Store the keyid (hash160) together with the child index counter in the
     // database as a hdchain object.
     CHDChain newHdChain;
     newHdChain.nVersion = m_storage.CanSupportFeature(FEATURE_HD_SPLIT)
                               ? CHDChain::VERSION_HD_CHAIN_SPLIT
                               : CHDChain::VERSION_HD_BASE;
     newHdChain.seed_id = seed.GetID();
     SetHDChain(newHdChain, false);
     NotifyCanGetAddressesChanged();
     WalletBatch batch(m_storage.GetDatabase());
     m_storage.UnsetBlankWalletFlag(batch);
 }
 
 /**
  * Mark old keypool keys as used, and generate all new keys.
  */
 bool LegacyScriptPubKeyMan::NewKeyPool() {
     if (m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         return false;
     }
     LOCK(cs_KeyStore);
     WalletBatch batch(m_storage.GetDatabase());
 
     for (const int64_t nIndex : setInternalKeyPool) {
         batch.ErasePool(nIndex);
     }
     setInternalKeyPool.clear();
 
     for (const int64_t nIndex : setExternalKeyPool) {
         batch.ErasePool(nIndex);
     }
     setExternalKeyPool.clear();
 
     for (int64_t nIndex : set_pre_split_keypool) {
         batch.ErasePool(nIndex);
     }
     set_pre_split_keypool.clear();
 
     m_pool_key_to_index.clear();
 
     if (!TopUp()) {
         return false;
     }
 
     WalletLogPrintf("LegacyScriptPubKeyMan::NewKeyPool rewrote keypool\n");
     return true;
 }
 
 bool LegacyScriptPubKeyMan::TopUp(unsigned int kpSize) {
     if (!CanGenerateKeys()) {
         return false;
     }
     {
         LOCK(cs_KeyStore);
 
         if (m_storage.IsLocked()) {
             return false;
         }
 
         // Top up key pool
         unsigned int nTargetSize;
         if (kpSize > 0) {
             nTargetSize = kpSize;
         } else {
             nTargetSize = std::max<int64_t>(
                 gArgs.GetArg("-keypool", DEFAULT_KEYPOOL_SIZE), 0);
         }
 
         // count amount of available keys (internal, external)
         // make sure the keypool of external and internal keys fits the user
         // selected target (-keypool)
         int64_t missingExternal = std::max<int64_t>(
             std::max<int64_t>(nTargetSize, 1) - setExternalKeyPool.size(), 0);
         int64_t missingInternal = std::max<int64_t>(
             std::max<int64_t>(nTargetSize, 1) - setInternalKeyPool.size(), 0);
 
         if (!IsHDEnabled() || !m_storage.CanSupportFeature(FEATURE_HD_SPLIT)) {
             // don't create extra internal keys
             missingInternal = 0;
         }
         bool internal = false;
         WalletBatch batch(m_storage.GetDatabase());
         for (int64_t i = missingInternal + missingExternal; i--;) {
             if (i < missingInternal) {
                 internal = true;
             }
 
             CPubKey pubkey(GenerateNewKey(batch, internal));
             AddKeypoolPubkeyWithDB(pubkey, internal, batch);
         }
         if (missingInternal + missingExternal > 0) {
             WalletLogPrintf(
                 "keypool added %d keys (%d internal), size=%u (%u internal)\n",
                 missingInternal + missingExternal, missingInternal,
                 setInternalKeyPool.size() + setExternalKeyPool.size() +
                     set_pre_split_keypool.size(),
                 setInternalKeyPool.size());
         }
     }
     NotifyCanGetAddressesChanged();
     return true;
 }
 
 void LegacyScriptPubKeyMan::AddKeypoolPubkeyWithDB(const CPubKey &pubkey,
                                                    const bool internal,
                                                    WalletBatch &batch) {
     LOCK(cs_KeyStore);
     // How in the hell did you use so many keys?
     assert(m_max_keypool_index < std::numeric_limits<int64_t>::max());
     int64_t index = ++m_max_keypool_index;
     if (!batch.WritePool(index, CKeyPool(pubkey, internal))) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing imported pubkey failed");
     }
     if (internal) {
         setInternalKeyPool.insert(index);
     } else {
         setExternalKeyPool.insert(index);
     }
     m_pool_key_to_index[pubkey.GetID()] = index;
 }
 
 void LegacyScriptPubKeyMan::KeepDestination(int64_t nIndex,
                                             const OutputType &type) {
     // Remove from key pool.
     WalletBatch batch(m_storage.GetDatabase());
     batch.ErasePool(nIndex);
     CPubKey pubkey;
     bool have_pk = GetPubKey(m_index_to_reserved_key.at(nIndex), pubkey);
     assert(have_pk);
     LearnRelatedScripts(pubkey, type);
     m_index_to_reserved_key.erase(nIndex);
     WalletLogPrintf("keypool keep %d\n", nIndex);
 }
 
 void LegacyScriptPubKeyMan::ReturnDestination(int64_t nIndex, bool fInternal,
                                               const CTxDestination &) {
     // Return to key pool
     {
         LOCK(cs_KeyStore);
         if (fInternal) {
             setInternalKeyPool.insert(nIndex);
         } else if (!set_pre_split_keypool.empty()) {
             set_pre_split_keypool.insert(nIndex);
         } else {
             setExternalKeyPool.insert(nIndex);
         }
         CKeyID &pubkey_id = m_index_to_reserved_key.at(nIndex);
         m_pool_key_to_index[pubkey_id] = nIndex;
         m_index_to_reserved_key.erase(nIndex);
         NotifyCanGetAddressesChanged();
     }
 
     WalletLogPrintf("keypool return %d\n", nIndex);
 }
 
 bool LegacyScriptPubKeyMan::GetKeyFromPool(CPubKey &result,
                                            const OutputType type,
                                            bool internal) {
     if (!CanGetAddresses(internal)) {
         return false;
     }
 
     CKeyPool keypool;
     LOCK(cs_KeyStore);
     int64_t nIndex;
     if (!ReserveKeyFromKeyPool(nIndex, keypool, internal) &&
         !m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         if (m_storage.IsLocked()) {
             return false;
         }
         WalletBatch batch(m_storage.GetDatabase());
         result = GenerateNewKey(batch, internal);
         return true;
     }
 
     KeepDestination(nIndex, type);
     result = keypool.vchPubKey;
 
     return true;
 }
 
 bool LegacyScriptPubKeyMan::ReserveKeyFromKeyPool(int64_t &nIndex,
                                                   CKeyPool &keypool,
                                                   bool fRequestedInternal) {
     nIndex = -1;
     keypool.vchPubKey = CPubKey();
     {
         LOCK(cs_KeyStore);
 
         bool fReturningInternal = fRequestedInternal;
         fReturningInternal &=
             (IsHDEnabled() && m_storage.CanSupportFeature(FEATURE_HD_SPLIT)) ||
             m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
         bool use_split_keypool = set_pre_split_keypool.empty();
         std::set<int64_t> &setKeyPool =
             use_split_keypool
                 ? (fReturningInternal ? setInternalKeyPool : setExternalKeyPool)
                 : set_pre_split_keypool;
 
         // Get the oldest key
         if (setKeyPool.empty()) {
             return false;
         }
 
         WalletBatch batch(m_storage.GetDatabase());
 
         auto it = setKeyPool.begin();
         nIndex = *it;
         setKeyPool.erase(it);
         if (!batch.ReadPool(nIndex, keypool)) {
             throw std::runtime_error(std::string(__func__) + ": read failed");
         }
         CPubKey pk;
         if (!GetPubKey(keypool.vchPubKey.GetID(), pk)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": unknown key in key pool");
         }
         // If the key was pre-split keypool, we don't care about what type it is
         if (use_split_keypool && keypool.fInternal != fReturningInternal) {
             throw std::runtime_error(std::string(__func__) +
                                      ": keypool entry misclassified");
         }
         if (!keypool.vchPubKey.IsValid()) {
             throw std::runtime_error(std::string(__func__) +
                                      ": keypool entry invalid");
         }
 
         assert(m_index_to_reserved_key.count(nIndex) == 0);
         m_index_to_reserved_key[nIndex] = keypool.vchPubKey.GetID();
         m_pool_key_to_index.erase(keypool.vchPubKey.GetID());
         WalletLogPrintf("keypool reserve %d\n", nIndex);
     }
     NotifyCanGetAddressesChanged();
     return true;
 }
 
 void LegacyScriptPubKeyMan::LearnRelatedScripts(const CPubKey &key,
                                                 OutputType type) {
     // Nothing to do...
 }
 
 void LegacyScriptPubKeyMan::LearnAllRelatedScripts(const CPubKey &key) {
     // Nothing to do...
 }
 
 void LegacyScriptPubKeyMan::MarkReserveKeysAsUsed(int64_t keypool_id) {
     AssertLockHeld(cs_KeyStore);
     bool internal = setInternalKeyPool.count(keypool_id);
     if (!internal) {
         assert(setExternalKeyPool.count(keypool_id) ||
                set_pre_split_keypool.count(keypool_id));
     }
 
     std::set<int64_t> *setKeyPool =
         internal ? &setInternalKeyPool
                  : (set_pre_split_keypool.empty() ? &setExternalKeyPool
                                                   : &set_pre_split_keypool);
     auto it = setKeyPool->begin();
 
     WalletBatch batch(m_storage.GetDatabase());
     while (it != std::end(*setKeyPool)) {
         const int64_t &index = *(it);
         if (index > keypool_id) {
             // set*KeyPool is ordered
             break;
         }
 
         CKeyPool keypool;
         if (batch.ReadPool(index, keypool)) {
             // TODO: This should be unnecessary
             m_pool_key_to_index.erase(keypool.vchPubKey.GetID());
         }
         LearnAllRelatedScripts(keypool.vchPubKey);
         batch.ErasePool(index);
         WalletLogPrintf("keypool index %d removed\n", index);
         it = setKeyPool->erase(it);
     }
 }
 
 std::vector<CKeyID> GetAffectedKeys(const CScript &spk,
                                     const SigningProvider &provider) {
     std::vector<CScript> dummy;
     FlatSigningProvider out;
     InferDescriptor(spk, provider)
         ->Expand(0, DUMMY_SIGNING_PROVIDER, dummy, out);
     std::vector<CKeyID> ret;
     for (const auto &entry : out.pubkeys) {
         ret.push_back(entry.first);
     }
     return ret;
 }
 
 void LegacyScriptPubKeyMan::MarkPreSplitKeys() {
     WalletBatch batch(m_storage.GetDatabase());
     for (auto it = setExternalKeyPool.begin();
          it != setExternalKeyPool.end();) {
         int64_t index = *it;
         CKeyPool keypool;
         if (!batch.ReadPool(index, keypool)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": read keypool entry failed");
         }
         keypool.m_pre_split = true;
         if (!batch.WritePool(index, keypool)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": writing modified keypool entry failed");
         }
         set_pre_split_keypool.insert(index);
         it = setExternalKeyPool.erase(it);
     }
 }
 
 bool LegacyScriptPubKeyMan::AddCScript(const CScript &redeemScript) {
     WalletBatch batch(m_storage.GetDatabase());
     return AddCScriptWithDB(batch, redeemScript);
 }
 
 bool LegacyScriptPubKeyMan::AddCScriptWithDB(WalletBatch &batch,
                                              const CScript &redeemScript) {
     if (!FillableSigningProvider::AddCScript(redeemScript)) {
         return false;
     }
     if (batch.WriteCScript(Hash160(redeemScript), redeemScript)) {
         m_storage.UnsetBlankWalletFlag(batch);
         return true;
     }
     return false;
 }
 
 bool LegacyScriptPubKeyMan::AddKeyOriginWithDB(WalletBatch &batch,
                                                const CPubKey &pubkey,
                                                const KeyOriginInfo &info) {
     LOCK(cs_KeyStore);
     std::copy(info.fingerprint, info.fingerprint + 4,
               mapKeyMetadata[pubkey.GetID()].key_origin.fingerprint);
     mapKeyMetadata[pubkey.GetID()].key_origin.path = info.path;
     mapKeyMetadata[pubkey.GetID()].has_key_origin = true;
     mapKeyMetadata[pubkey.GetID()].hdKeypath = WriteHDKeypath(info.path);
     return batch.WriteKeyMetadata(mapKeyMetadata[pubkey.GetID()], pubkey, true);
 }
 
 bool LegacyScriptPubKeyMan::ImportScripts(const std::set<CScript> scripts,
                                           int64_t timestamp) {
     WalletBatch batch(m_storage.GetDatabase());
     for (const auto &entry : scripts) {
         CScriptID id(entry);
         if (HaveCScript(id)) {
             WalletLogPrintf("Already have script %s, skipping\n",
                             HexStr(entry));
             continue;
         }
         if (!AddCScriptWithDB(batch, entry)) {
             return false;
         }
 
         if (timestamp > 0) {
             m_script_metadata[CScriptID(entry)].nCreateTime = timestamp;
         }
     }
     if (timestamp > 0) {
         UpdateTimeFirstKey(timestamp);
     }
 
     return true;
 }
 
 bool LegacyScriptPubKeyMan::ImportPrivKeys(
     const std::map<CKeyID, CKey> &privkey_map, const int64_t timestamp) {
     WalletBatch batch(m_storage.GetDatabase());
     for (const auto &entry : privkey_map) {
         const CKey &key = entry.second;
         CPubKey pubkey = key.GetPubKey();
         const CKeyID &id = entry.first;
         assert(key.VerifyPubKey(pubkey));
         // Skip if we already have the key
         if (HaveKey(id)) {
             WalletLogPrintf("Already have key with pubkey %s, skipping\n",
                             HexStr(pubkey));
             continue;
         }
         mapKeyMetadata[id].nCreateTime = timestamp;
         // If the private key is not present in the wallet, insert it.
         if (!AddKeyPubKeyWithDB(batch, key, pubkey)) {
             return false;
         }
         UpdateTimeFirstKey(timestamp);
     }
     return true;
 }
 
 bool LegacyScriptPubKeyMan::ImportPubKeys(
     const std::vector<CKeyID> &ordered_pubkeys,
     const std::map<CKeyID, CPubKey> &pubkey_map,
     const std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>> &key_origins,
     const bool add_keypool, const bool internal, const int64_t timestamp) {
     WalletBatch batch(m_storage.GetDatabase());
     for (const auto &entry : key_origins) {
         AddKeyOriginWithDB(batch, entry.second.first, entry.second.second);
     }
     for (const CKeyID &id : ordered_pubkeys) {
         auto entry = pubkey_map.find(id);
         if (entry == pubkey_map.end()) {
             continue;
         }
         const CPubKey &pubkey = entry->second;
         CPubKey temp;
         if (GetPubKey(id, temp)) {
             // Already have pubkey, skipping
             WalletLogPrintf("Already have pubkey %s, skipping\n", HexStr(temp));
             continue;
         }
         if (!AddWatchOnlyWithDB(batch, GetScriptForRawPubKey(pubkey),
                                 timestamp)) {
             return false;
         }
         mapKeyMetadata[id].nCreateTime = timestamp;
 
         // Add to keypool only works with pubkeys
         if (add_keypool) {
             AddKeypoolPubkeyWithDB(pubkey, internal, batch);
             NotifyCanGetAddressesChanged();
         }
     }
     return true;
 }
 
 bool LegacyScriptPubKeyMan::ImportScriptPubKeys(
     const std::set<CScript> &script_pub_keys, const bool have_solving_data,
     const int64_t timestamp) {
     WalletBatch batch(m_storage.GetDatabase());
     for (const CScript &script : script_pub_keys) {
         if (!have_solving_data || !IsMine(script)) {
             // Always call AddWatchOnly for non-solvable watch-only, so that
             // watch timestamp gets updated
             if (!AddWatchOnlyWithDB(batch, script, timestamp)) {
                 return false;
             }
         }
     }
     return true;
 }
 
 std::set<CKeyID> LegacyScriptPubKeyMan::GetKeys() const {
     LOCK(cs_KeyStore);
     if (!m_storage.HasEncryptionKeys()) {
         return FillableSigningProvider::GetKeys();
     }
     std::set<CKeyID> set_address;
     for (const auto &mi : mapCryptedKeys) {
         set_address.insert(mi.first);
     }
     return set_address;
 }
 
 void LegacyScriptPubKeyMan::SetType(OutputType type, bool internal) {}
 
 bool DescriptorScriptPubKeyMan::GetNewDestination(const OutputType type,
                                                   CTxDestination &dest,
                                                   std::string &error) {
     // Returns true if this descriptor supports getting new addresses.
     // Conditions where we may be unable to fetch them (e.g. locked) are caught
     // later
     if (!CanGetAddresses(m_internal)) {
         error = "No addresses available";
         return false;
     }
     {
         LOCK(cs_desc_man);
         // This is a combo descriptor which should not be an active descriptor
         assert(m_wallet_descriptor.descriptor->IsSingleType());
         if (type != m_address_type) {
             throw std::runtime_error(std::string(__func__) +
                                      ": Types are inconsistent");
         }
 
         TopUp();
 
         // Get the scriptPubKey from the descriptor
         FlatSigningProvider out_keys;
         std::vector<CScript> scripts_temp;
         if (m_wallet_descriptor.range_end <= m_max_cached_index && !TopUp(1)) {
             // We can't generate anymore keys
             error = "Error: Keypool ran out, please call keypoolrefill first";
             return false;
         }
         if (!m_wallet_descriptor.descriptor->ExpandFromCache(
                 m_wallet_descriptor.next_index, m_wallet_descriptor.cache,
                 scripts_temp, out_keys)) {
             // We can't generate anymore keys
             error = "Error: Keypool ran out, please call keypoolrefill first";
             return false;
         }
 
         std::optional<OutputType> out_script_type =
             m_wallet_descriptor.descriptor->GetOutputType();
         if (out_script_type && out_script_type == type) {
             ExtractDestination(scripts_temp[0], dest);
         } else {
             throw std::runtime_error(
                 std::string(__func__) +
                 ": Types are inconsistent. Stored type does not match type of "
                 "newly generated address");
         }
         m_wallet_descriptor.next_index++;
         WalletBatch(m_storage.GetDatabase())
             .WriteDescriptor(GetID(), m_wallet_descriptor);
         return true;
     }
 }
 
 isminetype DescriptorScriptPubKeyMan::IsMine(const CScript &script) const {
     LOCK(cs_desc_man);
     if (m_map_script_pub_keys.count(script) > 0) {
         return ISMINE_SPENDABLE;
     }
     return ISMINE_NO;
 }
 
 bool DescriptorScriptPubKeyMan::CheckDecryptionKey(
     const CKeyingMaterial &master_key, bool accept_no_keys) {
     LOCK(cs_desc_man);
     if (!m_map_keys.empty()) {
         return false;
     }
 
     // Always pass when there are no encrypted keys
     bool keyPass = m_map_crypted_keys.empty();
     bool keyFail = false;
     for (const auto &mi : m_map_crypted_keys) {
         const CPubKey &pubkey = mi.second.first;
         const std::vector<uint8_t> &crypted_secret = mi.second.second;
         CKey key;
         if (!DecryptKey(master_key, crypted_secret, pubkey, key)) {
             keyFail = true;
             break;
         }
         keyPass = true;
         if (m_decryption_thoroughly_checked) {
             break;
         }
     }
     if (keyPass && keyFail) {
         LogPrintf("The wallet is probably corrupted: Some keys decrypt but not "
                   "all.\n");
         throw std::runtime_error(
             "Error unlocking wallet: some keys decrypt but not all. Your "
             "wallet file may be corrupt.");
     }
     if (keyFail || (!keyPass && !accept_no_keys)) {
         return false;
     }
     m_decryption_thoroughly_checked = true;
     return true;
 }
 
 bool DescriptorScriptPubKeyMan::Encrypt(const CKeyingMaterial &master_key,
                                         WalletBatch *batch) {
     LOCK(cs_desc_man);
     if (!m_map_crypted_keys.empty()) {
         return false;
     }
 
     for (const KeyMap::value_type &key_in : m_map_keys) {
         const CKey &key = key_in.second;
         CPubKey pubkey = key.GetPubKey();
         CKeyingMaterial secret(key.begin(), key.end());
         std::vector<uint8_t> crypted_secret;
         if (!EncryptSecret(master_key, secret, pubkey.GetHash(),
                            crypted_secret)) {
             return false;
         }
         m_map_crypted_keys[pubkey.GetID()] = make_pair(pubkey, crypted_secret);
         batch->WriteCryptedDescriptorKey(GetID(), pubkey, crypted_secret);
     }
     m_map_keys.clear();
     return true;
 }
 
 bool DescriptorScriptPubKeyMan::GetReservedDestination(const OutputType type,
                                                        bool internal,
                                                        CTxDestination &address,
                                                        int64_t &index,
                                                        CKeyPool &keypool) {
     LOCK(cs_desc_man);
     std::string error;
     bool result = GetNewDestination(type, address, error);
     index = m_wallet_descriptor.next_index - 1;
     return result;
 }
 
 void DescriptorScriptPubKeyMan::ReturnDestination(int64_t index, bool internal,
                                                   const CTxDestination &addr) {
     LOCK(cs_desc_man);
     // Only return when the index was the most recent
     if (m_wallet_descriptor.next_index - 1 == index) {
         m_wallet_descriptor.next_index--;
     }
     WalletBatch(m_storage.GetDatabase())
         .WriteDescriptor(GetID(), m_wallet_descriptor);
     NotifyCanGetAddressesChanged();
 }
 
 std::map<CKeyID, CKey> DescriptorScriptPubKeyMan::GetKeys() const {
     AssertLockHeld(cs_desc_man);
     if (m_storage.HasEncryptionKeys() && !m_storage.IsLocked()) {
         KeyMap keys;
         for (auto key_pair : m_map_crypted_keys) {
             const CPubKey &pubkey = key_pair.second.first;
             const std::vector<uint8_t> &crypted_secret = key_pair.second.second;
             CKey key;
             DecryptKey(m_storage.GetEncryptionKey(), crypted_secret, pubkey,
                        key);
             keys[pubkey.GetID()] = key;
         }
         return keys;
     }
     return m_map_keys;
 }
 
 bool DescriptorScriptPubKeyMan::TopUp(unsigned int size) {
     LOCK(cs_desc_man);
     unsigned int target_size;
     if (size > 0) {
         target_size = size;
     } else {
         target_size = std::max(gArgs.GetArg("-keypool", DEFAULT_KEYPOOL_SIZE),
                                int64_t(1));
     }
 
     // Calculate the new range_end
     int32_t new_range_end =
         std::max(m_wallet_descriptor.next_index + int32_t(target_size),
                  m_wallet_descriptor.range_end);
 
     // If the descriptor is not ranged, we actually just want to fill the first
     // cache item
     if (!m_wallet_descriptor.descriptor->IsRange()) {
         new_range_end = 1;
         m_wallet_descriptor.range_end = 1;
         m_wallet_descriptor.range_start = 0;
     }
 
     FlatSigningProvider provider;
     provider.keys = GetKeys();
 
     WalletBatch batch(m_storage.GetDatabase());
     uint256 id = GetID();
     for (int32_t i = m_max_cached_index + 1; i < new_range_end; ++i) {
         FlatSigningProvider out_keys;
         std::vector<CScript> scripts_temp;
         DescriptorCache temp_cache;
         // Maybe we have a cached xpub and we can expand from the cache first
         if (!m_wallet_descriptor.descriptor->ExpandFromCache(
                 i, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
             if (!m_wallet_descriptor.descriptor->Expand(
                     i, provider, scripts_temp, out_keys, &temp_cache)) {
                 return false;
             }
         }
         // Add all of the scriptPubKeys to the scriptPubKey set
         for (const CScript &script : scripts_temp) {
             m_map_script_pub_keys[script] = i;
         }
         for (const auto &pk_pair : out_keys.pubkeys) {
             const CPubKey &pubkey = pk_pair.second;
             if (m_map_pubkeys.count(pubkey) != 0) {
                 // We don't need to give an error here.
                 // It doesn't matter which of many valid indexes the pubkey has,
                 // we just need an index where we can derive it and it's private
                 // key
                 continue;
             }
             m_map_pubkeys[pubkey] = i;
         }
         // Write the cache
         for (const auto &parent_xpub_pair :
              temp_cache.GetCachedParentExtPubKeys()) {
             CExtPubKey xpub;
             if (m_wallet_descriptor.cache.GetCachedParentExtPubKey(
                     parent_xpub_pair.first, xpub)) {
                 if (xpub != parent_xpub_pair.second) {
                     throw std::runtime_error(
                         std::string(__func__) +
                         ": New cached parent xpub does not match already "
                         "cached parent xpub");
                 }
                 continue;
             }
             if (!batch.WriteDescriptorParentCache(parent_xpub_pair.second, id,
                                                   parent_xpub_pair.first)) {
                 throw std::runtime_error(std::string(__func__) +
                                          ": writing cache item failed");
             }
             m_wallet_descriptor.cache.CacheParentExtPubKey(
                 parent_xpub_pair.first, parent_xpub_pair.second);
         }
         for (const auto &derived_xpub_map_pair :
              temp_cache.GetCachedDerivedExtPubKeys()) {
             for (const auto &derived_xpub_pair : derived_xpub_map_pair.second) {
                 CExtPubKey xpub;
                 if (m_wallet_descriptor.cache.GetCachedDerivedExtPubKey(
                         derived_xpub_map_pair.first, derived_xpub_pair.first,
                         xpub)) {
                     if (xpub != derived_xpub_pair.second) {
                         throw std::runtime_error(
                             std::string(__func__) +
                             ": New cached derived xpub does not match already "
                             "cached derived xpub");
                     }
                     continue;
                 }
                 if (!batch.WriteDescriptorDerivedCache(
                         derived_xpub_pair.second, id,
                         derived_xpub_map_pair.first, derived_xpub_pair.first)) {
                     throw std::runtime_error(std::string(__func__) +
                                              ": writing cache item failed");
                 }
                 m_wallet_descriptor.cache.CacheDerivedExtPubKey(
                     derived_xpub_map_pair.first, derived_xpub_pair.first,
                     derived_xpub_pair.second);
             }
         }
         m_max_cached_index++;
     }
     m_wallet_descriptor.range_end = new_range_end;
     batch.WriteDescriptor(GetID(), m_wallet_descriptor);
 
     // By this point, the cache size should be the size of the entire range
     assert(m_wallet_descriptor.range_end - 1 == m_max_cached_index);
 
     NotifyCanGetAddressesChanged();
     return true;
 }
 
 void DescriptorScriptPubKeyMan::MarkUnusedAddresses(const CScript &script) {
     LOCK(cs_desc_man);
     if (IsMine(script)) {
         int32_t index = m_map_script_pub_keys[script];
         if (index >= m_wallet_descriptor.next_index) {
             WalletLogPrintf("%s: Detected a used keypool item at index %d, "
                             "mark all keypool items up to this item as used\n",
                             __func__, index);
             m_wallet_descriptor.next_index = index + 1;
         }
         if (!TopUp()) {
             WalletLogPrintf("%s: Topping up keypool failed (locked wallet)\n",
                             __func__);
         }
     }
 }
 
 void DescriptorScriptPubKeyMan::AddDescriptorKey(const CKey &key,
                                                  const CPubKey &pubkey) {
     LOCK(cs_desc_man);
     WalletBatch batch(m_storage.GetDatabase());
     if (!AddDescriptorKeyWithDB(batch, key, pubkey)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing descriptor private key failed");
     }
 }
 
 bool DescriptorScriptPubKeyMan::AddDescriptorKeyWithDB(WalletBatch &batch,
                                                        const CKey &key,
                                                        const CPubKey &pubkey) {
     AssertLockHeld(cs_desc_man);
     assert(!m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
 
     if (m_storage.HasEncryptionKeys()) {
         if (m_storage.IsLocked()) {
             return false;
         }
 
         std::vector<uint8_t> crypted_secret;
         CKeyingMaterial secret(key.begin(), key.end());
         if (!EncryptSecret(m_storage.GetEncryptionKey(), secret,
                            pubkey.GetHash(), crypted_secret)) {
             return false;
         }
 
         m_map_crypted_keys[pubkey.GetID()] = make_pair(pubkey, crypted_secret);
         return batch.WriteCryptedDescriptorKey(GetID(), pubkey, crypted_secret);
     } else {
         m_map_keys[pubkey.GetID()] = key;
         return batch.WriteDescriptorKey(GetID(), pubkey, key.GetPrivKey());
     }
 }
 
 bool DescriptorScriptPubKeyMan::SetupDescriptorGeneration(
     const CExtKey &master_key) {
     LOCK(cs_desc_man);
     assert(m_storage.IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
 
     // Ignore when there is already a descriptor
     if (m_wallet_descriptor.descriptor) {
         return false;
     }
 
     int64_t creation_time = GetTime();
 
     std::string xpub = EncodeExtPubKey(master_key.Neuter());
 
     // Build descriptor string
     std::string desc_prefix;
     std::string desc_suffix = "/*)";
     switch (m_address_type) {
         case OutputType::LEGACY: {
             desc_prefix = "pkh(" + xpub + "/44'";
             break;
         }
         default:
             assert(false);
     }
 
     // Mainnet derives at 0', testnet and regtest derive at 1'
     if (m_storage.GetChainParams().IsTestChain()) {
         desc_prefix += "/1'";
     } else {
         desc_prefix += "/0'";
     }
 
     std::string internal_path = m_internal ? "/1" : "/0";
     std::string desc_str = desc_prefix + "/0'" + internal_path + desc_suffix;
 
     // Make the descriptor
     FlatSigningProvider keys;
     std::string error;
     std::unique_ptr<Descriptor> desc = Parse(desc_str, keys, error, false);
     WalletDescriptor w_desc(std::move(desc), creation_time, 0, 0, 0);
     m_wallet_descriptor = w_desc;
 
     // Store the master private key, and descriptor
     WalletBatch batch(m_storage.GetDatabase());
     if (!AddDescriptorKeyWithDB(batch, master_key.key,
                                 master_key.key.GetPubKey())) {
         throw std::runtime_error(
             std::string(__func__) +
             ": writing descriptor master private key failed");
     }
     if (!batch.WriteDescriptor(GetID(), m_wallet_descriptor)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing descriptor failed");
     }
 
     // TopUp
     TopUp();
 
     m_storage.UnsetBlankWalletFlag(batch);
     return true;
 }
 
 bool DescriptorScriptPubKeyMan::IsHDEnabled() const {
     LOCK(cs_desc_man);
     return m_wallet_descriptor.descriptor->IsRange();
 }
 
 bool DescriptorScriptPubKeyMan::CanGetAddresses(bool internal) const {
     // We can only give out addresses from descriptors that are single type (not
     // combo), ranged, and either have cached keys or can generate more keys
     // (ignoring encryption)
     LOCK(cs_desc_man);
     return m_wallet_descriptor.descriptor->IsSingleType() &&
            m_wallet_descriptor.descriptor->IsRange() &&
            (HavePrivateKeys() ||
             m_wallet_descriptor.next_index < m_wallet_descriptor.range_end);
 }
 
 bool DescriptorScriptPubKeyMan::HavePrivateKeys() const {
     LOCK(cs_desc_man);
     return m_map_keys.size() > 0 || m_map_crypted_keys.size() > 0;
 }
 
 int64_t DescriptorScriptPubKeyMan::GetOldestKeyPoolTime() const {
     // This is only used for getwalletinfo output and isn't relevant to
     // descriptor wallets. The magic number 0 indicates that it shouldn't be
     // displayed so that's what we return.
     return 0;
 }
 
 size_t DescriptorScriptPubKeyMan::KeypoolCountExternalKeys() const {
     if (m_internal) {
         return 0;
     }
     return GetKeyPoolSize();
 }
 
 unsigned int DescriptorScriptPubKeyMan::GetKeyPoolSize() const {
     LOCK(cs_desc_man);
     return m_wallet_descriptor.range_end - m_wallet_descriptor.next_index;
 }
 
 int64_t DescriptorScriptPubKeyMan::GetTimeFirstKey() const {
     LOCK(cs_desc_man);
     return m_wallet_descriptor.creation_time;
 }
 
 std::unique_ptr<FlatSigningProvider>
 DescriptorScriptPubKeyMan::GetSigningProvider(const CScript &script,
                                               bool include_private) const {
     LOCK(cs_desc_man);
 
     // Find the index of the script
     auto it = m_map_script_pub_keys.find(script);
     if (it == m_map_script_pub_keys.end()) {
         return nullptr;
     }
     int32_t index = it->second;
 
     return GetSigningProvider(index, include_private);
 }
 
 std::unique_ptr<FlatSigningProvider>
 DescriptorScriptPubKeyMan::GetSigningProvider(const CPubKey &pubkey) const {
     LOCK(cs_desc_man);
 
     // Find index of the pubkey
     auto it = m_map_pubkeys.find(pubkey);
     if (it == m_map_pubkeys.end()) {
         return nullptr;
     }
     int32_t index = it->second;
 
     // Always try to get the signing provider with private keys. This function
     // should only be called during signing anyways
     return GetSigningProvider(index, true);
 }
 
 std::unique_ptr<FlatSigningProvider>
 DescriptorScriptPubKeyMan::GetSigningProvider(int32_t index,
                                               bool include_private) const {
     AssertLockHeld(cs_desc_man);
     // Get the scripts, keys, and key origins for this script
     std::unique_ptr<FlatSigningProvider> out_keys =
         std::make_unique<FlatSigningProvider>();
     std::vector<CScript> scripts_temp;
     if (!m_wallet_descriptor.descriptor->ExpandFromCache(
             index, m_wallet_descriptor.cache, scripts_temp, *out_keys)) {
         return nullptr;
     }
 
     if (HavePrivateKeys() && include_private) {
         FlatSigningProvider master_provider;
         master_provider.keys = GetKeys();
         m_wallet_descriptor.descriptor->ExpandPrivate(index, master_provider,
                                                       *out_keys);
     }
 
     return out_keys;
 }
 
 std::unique_ptr<SigningProvider>
 DescriptorScriptPubKeyMan::GetSolvingProvider(const CScript &script) const {
     return GetSigningProvider(script, false);
 }
 
 bool DescriptorScriptPubKeyMan::CanProvide(const CScript &script,
                                            SignatureData &sigdata) {
     return IsMine(script);
 }
 
 bool DescriptorScriptPubKeyMan::SignTransaction(
     CMutableTransaction &tx, const std::map<COutPoint, Coin> &coins,
     SigHashType sighash, std::map<int, std::string> &input_errors) const {
     std::unique_ptr<FlatSigningProvider> keys =
         std::make_unique<FlatSigningProvider>();
     for (const auto &coin_pair : coins) {
         std::unique_ptr<FlatSigningProvider> coin_keys =
             GetSigningProvider(coin_pair.second.GetTxOut().scriptPubKey, true);
         if (!coin_keys) {
             continue;
         }
         *keys = Merge(*keys, *coin_keys);
     }
 
     return ::SignTransaction(tx, keys.get(), coins, sighash, input_errors);
 }
 
 SigningResult
 DescriptorScriptPubKeyMan::SignMessage(const std::string &message,
                                        const PKHash &pkhash,
                                        std::string &str_sig) const {
     std::unique_ptr<FlatSigningProvider> keys =
         GetSigningProvider(GetScriptForDestination(pkhash), true);
     if (!keys) {
         return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
     }
 
     CKeyID key_id(pkhash);
     CKey key;
     if (!keys->GetKey(key_id, key)) {
         return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
     }
 
     if (!MessageSign(key, message, str_sig)) {
         return SigningResult::SIGNING_FAILED;
     }
     return SigningResult::OK;
 }
 
 TransactionError
 DescriptorScriptPubKeyMan::FillPSBT(PartiallySignedTransaction &psbtx,
                                     SigHashType sighash_type, bool sign,
                                     bool bip32derivs) const {
     for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
         PSBTInput &input = psbtx.inputs.at(i);
 
         if (PSBTInputSigned(input)) {
             continue;
         }
 
-        // Verify input looks sane. This will check that we have at most one
-        // uxto, witness or non-witness.
-        if (!input.IsSane()) {
-            return TransactionError::INVALID_PSBT;
-        }
-
         // Get the Sighash type
         if (sign && input.sighash_type.getRawSigHashType() > 0 &&
             input.sighash_type != sighash_type) {
             return TransactionError::SIGHASH_MISMATCH;
         }
 
         // Get the scriptPubKey to know which SigningProvider to use
         CScript script;
         if (!input.utxo.IsNull()) {
             script = input.utxo.scriptPubKey;
         } else {
             // There's no UTXO so we can just skip this now
             continue;
         }
         SignatureData sigdata;
         input.FillSignatureData(sigdata);
 
         std::unique_ptr<FlatSigningProvider> keys =
             std::make_unique<FlatSigningProvider>();
         std::unique_ptr<FlatSigningProvider> script_keys =
             GetSigningProvider(script, sign);
         if (script_keys) {
             *keys = Merge(*keys, *script_keys);
         } else {
             // Maybe there are pubkeys listed that we can sign for
             script_keys = std::make_unique<FlatSigningProvider>();
             for (const auto &pk_pair : input.hd_keypaths) {
                 const CPubKey &pubkey = pk_pair.first;
                 std::unique_ptr<FlatSigningProvider> pk_keys =
                     GetSigningProvider(pubkey);
                 if (pk_keys) {
                     *keys = Merge(*keys, *pk_keys);
                 }
             }
         }
 
         SignPSBTInput(HidingSigningProvider(keys.get(), !sign, !bip32derivs),
                       psbtx, i, sighash_type);
     }
 
     // Fill in the bip32 keypaths and redeemscripts for the outputs so that
     // hardware wallets can identify change
     for (size_t i = 0; i < psbtx.tx->vout.size(); ++i) {
         std::unique_ptr<SigningProvider> keys =
             GetSolvingProvider(psbtx.tx->vout.at(i).scriptPubKey);
         if (!keys) {
             continue;
         }
         UpdatePSBTOutput(HidingSigningProvider(keys.get(), true, !bip32derivs),
                          psbtx, i);
     }
 
     return TransactionError::OK;
 }
 
 std::unique_ptr<CKeyMetadata>
 DescriptorScriptPubKeyMan::GetMetadata(const CTxDestination &dest) const {
     std::unique_ptr<SigningProvider> provider =
         GetSigningProvider(GetScriptForDestination(dest));
     if (provider) {
         KeyOriginInfo orig;
         CKeyID key_id = GetKeyForDestination(*provider, dest);
         if (provider->GetKeyOrigin(key_id, orig)) {
             LOCK(cs_desc_man);
             std::unique_ptr<CKeyMetadata> meta =
                 std::make_unique<CKeyMetadata>();
             meta->key_origin = orig;
             meta->has_key_origin = true;
             meta->nCreateTime = m_wallet_descriptor.creation_time;
             return meta;
         }
     }
     return nullptr;
 }
 
 uint256 DescriptorScriptPubKeyMan::GetID() const {
     LOCK(cs_desc_man);
     std::string desc_str = m_wallet_descriptor.descriptor->ToString();
     uint256 id;
     CSHA256()
         .Write((uint8_t *)desc_str.data(), desc_str.size())
         .Finalize(id.begin());
     return id;
 }
 
 void DescriptorScriptPubKeyMan::SetType(OutputType type, bool internal) {
     this->m_address_type = type;
     this->m_internal = internal;
 }
 
 void DescriptorScriptPubKeyMan::SetCache(const DescriptorCache &cache) {
     LOCK(cs_desc_man);
     m_wallet_descriptor.cache = cache;
     for (int32_t i = m_wallet_descriptor.range_start;
          i < m_wallet_descriptor.range_end; ++i) {
         FlatSigningProvider out_keys;
         std::vector<CScript> scripts_temp;
         if (!m_wallet_descriptor.descriptor->ExpandFromCache(
                 i, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
             throw std::runtime_error(
                 "Error: Unable to expand wallet descriptor from cache");
         }
         // Add all of the scriptPubKeys to the scriptPubKey set
         for (const CScript &script : scripts_temp) {
             if (m_map_script_pub_keys.count(script) != 0) {
                 throw std::runtime_error(
                     strprintf("Error: Already loaded script at index %d as "
                               "being at index %d",
                               i, m_map_script_pub_keys[script]));
             }
             m_map_script_pub_keys[script] = i;
         }
         for (const auto &pk_pair : out_keys.pubkeys) {
             const CPubKey &pubkey = pk_pair.second;
             if (m_map_pubkeys.count(pubkey) != 0) {
                 // We don't need to give an error here.
                 // It doesn't matter which of many valid indexes the pubkey has,
                 // we just need an index where we can derive it and it's private
                 // key
                 continue;
             }
             m_map_pubkeys[pubkey] = i;
         }
         m_max_cached_index++;
     }
 }
 
 bool DescriptorScriptPubKeyMan::AddKey(const CKeyID &key_id, const CKey &key) {
     LOCK(cs_desc_man);
     m_map_keys[key_id] = key;
     return true;
 }
 
 bool DescriptorScriptPubKeyMan::AddCryptedKey(
     const CKeyID &key_id, const CPubKey &pubkey,
     const std::vector<uint8_t> &crypted_key) {
     LOCK(cs_desc_man);
     if (!m_map_keys.empty()) {
         return false;
     }
 
     m_map_crypted_keys[key_id] = make_pair(pubkey, crypted_key);
     return true;
 }
 
 bool DescriptorScriptPubKeyMan::HasWalletDescriptor(
     const WalletDescriptor &desc) const {
     LOCK(cs_desc_man);
     return m_wallet_descriptor.descriptor != nullptr &&
            desc.descriptor != nullptr &&
            m_wallet_descriptor.descriptor->ToString() ==
                desc.descriptor->ToString();
 }
 
 void DescriptorScriptPubKeyMan::WriteDescriptor() {
     LOCK(cs_desc_man);
     WalletBatch batch(m_storage.GetDatabase());
     if (!batch.WriteDescriptor(GetID(), m_wallet_descriptor)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing descriptor failed");
     }
 }
 
 const WalletDescriptor DescriptorScriptPubKeyMan::GetWalletDescriptor() const {
     return m_wallet_descriptor;
 }
 
 const std::vector<CScript> DescriptorScriptPubKeyMan::GetScriptPubKeys() const {
     LOCK(cs_desc_man);
     std::vector<CScript> script_pub_keys;
     script_pub_keys.reserve(m_map_script_pub_keys.size());
 
     for (auto const &script_pub_key : m_map_script_pub_keys) {
         script_pub_keys.push_back(script_pub_key.first);
     }
     return script_pub_keys;
 }
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 880c0a3d2..26758a9bd 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -1,5051 +1,5046 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // 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.
 
 #include <wallet/wallet.h>
 
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/consensus.h>
 #include <consensus/validation.h>
 #include <fs.h>
 #include <interfaces/wallet.h>
 #include <key.h>
 #include <key_io.h>
 #include <policy/mempool.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <script/descriptor.h>
 #include <script/script.h>
 #include <script/sighashtype.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
 #include <util/bip32.h>
 #include <util/check.h>
 #include <util/error.h>
 #include <util/moneystr.h>
 #include <util/string.h>
 #include <util/translation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/fees.h>
 
 #include <boost/algorithm/string/replace.hpp>
 
 using interfaces::FoundBlock;
 
 const std::map<uint64_t, std::string> WALLET_FLAG_CAVEATS{
     {WALLET_FLAG_AVOID_REUSE,
      "You need to rescan the blockchain in order to correctly mark used "
      "destinations in the past. Until this is done, some destinations may "
      "be considered unused, even if the opposite is the case."},
 };
 
 static RecursiveMutex cs_wallets;
 static std::vector<std::shared_ptr<CWallet>> vpwallets GUARDED_BY(cs_wallets);
 static std::list<LoadWalletFn> g_load_wallet_fns GUARDED_BY(cs_wallets);
 
 bool AddWallet(const std::shared_ptr<CWallet> &wallet) {
     LOCK(cs_wallets);
     assert(wallet);
     std::vector<std::shared_ptr<CWallet>>::const_iterator i =
         std::find(vpwallets.begin(), vpwallets.end(), wallet);
     if (i != vpwallets.end()) {
         return false;
     }
     vpwallets.push_back(wallet);
     wallet->ConnectScriptPubKeyManNotifiers();
     return true;
 }
 
 bool RemoveWallet(const std::shared_ptr<CWallet> &wallet) {
     assert(wallet);
     // Unregister with the validation interface which also drops shared ponters.
     wallet->m_chain_notifications_handler.reset();
     LOCK(cs_wallets);
     std::vector<std::shared_ptr<CWallet>>::iterator i =
         std::find(vpwallets.begin(), vpwallets.end(), wallet);
     if (i == vpwallets.end()) {
         return false;
     }
     vpwallets.erase(i);
     return true;
 }
 
 bool HasWallets() {
     LOCK(cs_wallets);
     return !vpwallets.empty();
 }
 
 std::vector<std::shared_ptr<CWallet>> GetWallets() {
     LOCK(cs_wallets);
     return vpwallets;
 }
 
 std::shared_ptr<CWallet> GetWallet(const std::string &name) {
     LOCK(cs_wallets);
     for (const std::shared_ptr<CWallet> &wallet : vpwallets) {
         if (wallet->GetName() == name) {
             return wallet;
         }
     }
     return nullptr;
 }
 
 std::unique_ptr<interfaces::Handler>
 HandleLoadWallet(LoadWalletFn load_wallet) {
     LOCK(cs_wallets);
     auto it = g_load_wallet_fns.emplace(g_load_wallet_fns.end(),
                                         std::move(load_wallet));
     return interfaces::MakeHandler([it] {
         LOCK(cs_wallets);
         g_load_wallet_fns.erase(it);
     });
 }
 
 static Mutex g_wallet_release_mutex;
 static std::condition_variable g_wallet_release_cv;
 static std::set<std::string> g_unloading_wallet_set;
 
 // Custom deleter for shared_ptr<CWallet>.
 static void ReleaseWallet(CWallet *wallet) {
     const std::string name = wallet->GetName();
     wallet->WalletLogPrintf("Releasing wallet\n");
     wallet->Flush();
     delete wallet;
     // Wallet is now released, notify UnloadWallet, if any.
     {
         LOCK(g_wallet_release_mutex);
         if (g_unloading_wallet_set.erase(name) == 0) {
             // UnloadWallet was not called for this wallet, all done.
             return;
         }
     }
     g_wallet_release_cv.notify_all();
 }
 
 void UnloadWallet(std::shared_ptr<CWallet> &&wallet) {
     // Mark wallet for unloading.
     const std::string name = wallet->GetName();
     {
         LOCK(g_wallet_release_mutex);
         auto it = g_unloading_wallet_set.insert(name);
         assert(it.second);
     }
     // The wallet can be in use so it's not possible to explicitly unload here.
     // Notify the unload intent so that all remaining shared pointers are
     // released.
     wallet->NotifyUnload();
 
     // Time to ditch our shared_ptr and wait for ReleaseWallet call.
     wallet.reset();
     {
         WAIT_LOCK(g_wallet_release_mutex, lock);
         while (g_unloading_wallet_set.count(name) == 1) {
             g_wallet_release_cv.wait(lock);
         }
     }
 }
 
 static const size_t OUTPUT_GROUP_MAX_ENTRIES = 10;
 
 std::shared_ptr<CWallet> LoadWallet(const CChainParams &chainParams,
                                     interfaces::Chain &chain,
                                     const WalletLocation &location,
                                     bilingual_str &error,
                                     std::vector<bilingual_str> &warnings) {
     try {
         if (!CWallet::Verify(chainParams, chain, location, error, warnings)) {
             error = Untranslated("Wallet file verification failed.") +
                     Untranslated(" ") + error;
             return nullptr;
         }
 
         std::shared_ptr<CWallet> wallet = CWallet::CreateWalletFromFile(
             chainParams, chain, location, error, warnings);
         if (!wallet) {
             error = Untranslated("Wallet loading failed.") + Untranslated(" ") +
                     error;
             return nullptr;
         }
         AddWallet(wallet);
         wallet->postInitProcess();
         return wallet;
     } catch (const std::runtime_error &e) {
         error = Untranslated(e.what());
         return nullptr;
     }
 }
 
 std::shared_ptr<CWallet> LoadWallet(const CChainParams &chainParams,
                                     interfaces::Chain &chain,
                                     const std::string &name,
                                     bilingual_str &error,
                                     std::vector<bilingual_str> &warnings) {
     return LoadWallet(chainParams, chain, WalletLocation(name), error,
                       warnings);
 }
 
 WalletCreationStatus CreateWallet(const CChainParams &params,
                                   interfaces::Chain &chain,
                                   const SecureString &passphrase,
                                   uint64_t wallet_creation_flags,
                                   const std::string &name, bilingual_str &error,
                                   std::vector<bilingual_str> &warnings,
                                   std::shared_ptr<CWallet> &result) {
     // Indicate that the wallet is actually supposed to be blank and not just
     // blank to make it encrypted
     bool create_blank = (wallet_creation_flags & WALLET_FLAG_BLANK_WALLET);
 
     // Born encrypted wallets need to be created blank first.
     if (!passphrase.empty()) {
         wallet_creation_flags |= WALLET_FLAG_BLANK_WALLET;
     }
 
     // Check the wallet file location
     WalletLocation location(name);
     if (location.Exists()) {
         error = strprintf(Untranslated("Wallet %s already exists."),
                           location.GetName());
         return WalletCreationStatus::CREATION_FAILED;
     }
 
     // Wallet::Verify will check if we're trying to create a wallet with a
     // duplicate name.
     if (!CWallet::Verify(params, chain, location, error, warnings)) {
         error = Untranslated("Wallet file verification failed.") +
                 Untranslated(" ") + error;
         return WalletCreationStatus::CREATION_FAILED;
     }
 
     // Do not allow a passphrase when private keys are disabled
     if (!passphrase.empty() &&
         (wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         error = Untranslated(
             "Passphrase provided but private keys are disabled. A passphrase "
             "is only used to encrypt private keys, so cannot be used for "
             "wallets with private keys disabled.");
         return WalletCreationStatus::CREATION_FAILED;
     }
 
     // Make the wallet
     std::shared_ptr<CWallet> wallet = CWallet::CreateWalletFromFile(
         params, chain, location, error, warnings, wallet_creation_flags);
     if (!wallet) {
         error =
             Untranslated("Wallet creation failed.") + Untranslated(" ") + error;
         return WalletCreationStatus::CREATION_FAILED;
     }
 
     // Encrypt the wallet
     if (!passphrase.empty() &&
         !(wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         if (!wallet->EncryptWallet(passphrase)) {
             error =
                 Untranslated("Error: Wallet created but failed to encrypt.");
             return WalletCreationStatus::ENCRYPTION_FAILED;
         }
         if (!create_blank) {
             // Unlock the wallet
             if (!wallet->Unlock(passphrase)) {
                 error = Untranslated(
                     "Error: Wallet was encrypted but could not be unlocked");
                 return WalletCreationStatus::ENCRYPTION_FAILED;
             }
 
             // Set a seed for the wallet
             {
                 LOCK(wallet->cs_wallet);
                 if (wallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
                     wallet->SetupDescriptorScriptPubKeyMans();
                 } else {
                     for (auto spk_man : wallet->GetActiveScriptPubKeyMans()) {
                         if (!spk_man->SetupGeneration()) {
                             error =
                                 Untranslated("Unable to generate initial keys");
                             return WalletCreationStatus::CREATION_FAILED;
                         }
                     }
                 }
             }
 
             // Relock the wallet
             wallet->Lock();
         }
     }
     AddWallet(wallet);
     wallet->postInitProcess();
     result = wallet;
     return WalletCreationStatus::SUCCESS;
 }
 
 const BlockHash CWalletTx::ABANDON_HASH(UINT256_ONE());
 
 /** @defgroup mapWallet
  *
  * @{
  */
 
 std::string COutput::ToString() const {
     return strprintf("COutput(%s, %d, %d) [%s]", tx->GetId().ToString(), i,
                      nDepth, FormatMoney(tx->tx->vout[i].nValue));
 }
 
 const CChainParams &CWallet::GetChainParams() const {
     // Get CChainParams from interfaces::Chain, unless wallet doesn't have a
     // chain (i.e. bitcoin-wallet), in which case return global Params()
     return m_chain ? m_chain->params() : Params();
 }
 
 const CWalletTx *CWallet::GetWalletTx(const TxId &txid) const {
     LOCK(cs_wallet);
     std::map<TxId, CWalletTx>::const_iterator it = mapWallet.find(txid);
     if (it == mapWallet.end()) {
         return nullptr;
     }
 
     return &(it->second);
 }
 
 void CWallet::UpgradeKeyMetadata() {
     if (IsLocked() || IsWalletFlagSet(WALLET_FLAG_KEY_ORIGIN_METADATA)) {
         return;
     }
 
     auto spk_man = GetLegacyScriptPubKeyMan();
     if (!spk_man) {
         return;
     }
 
     spk_man->UpgradeKeyMetadata();
     SetWalletFlag(WALLET_FLAG_KEY_ORIGIN_METADATA);
 }
 
 bool CWallet::Unlock(const SecureString &strWalletPassphrase,
                      bool accept_no_keys) {
     CCrypter crypter;
     CKeyingMaterial _vMasterKey;
 
     {
         LOCK(cs_wallet);
         for (const MasterKeyMap::value_type &pMasterKey : mapMasterKeys) {
             if (!crypter.SetKeyFromPassphrase(
                     strWalletPassphrase, pMasterKey.second.vchSalt,
                     pMasterKey.second.nDeriveIterations,
                     pMasterKey.second.nDerivationMethod)) {
                 return false;
             }
             if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey,
                                  _vMasterKey)) {
                 // try another master key
                 continue;
             }
             if (Unlock(_vMasterKey, accept_no_keys)) {
                 // Now that we've unlocked, upgrade the key metadata
                 UpgradeKeyMetadata();
                 return true;
             }
         }
     }
 
     return false;
 }
 
 bool CWallet::ChangeWalletPassphrase(
     const SecureString &strOldWalletPassphrase,
     const SecureString &strNewWalletPassphrase) {
     bool fWasLocked = IsLocked();
 
     LOCK(cs_wallet);
     Lock();
 
     CCrypter crypter;
     CKeyingMaterial _vMasterKey;
     for (MasterKeyMap::value_type &pMasterKey : mapMasterKeys) {
         if (!crypter.SetKeyFromPassphrase(
                 strOldWalletPassphrase, pMasterKey.second.vchSalt,
                 pMasterKey.second.nDeriveIterations,
                 pMasterKey.second.nDerivationMethod)) {
             return false;
         }
 
         if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, _vMasterKey)) {
             return false;
         }
 
         if (Unlock(_vMasterKey)) {
             int64_t nStartTime = GetTimeMillis();
             crypter.SetKeyFromPassphrase(strNewWalletPassphrase,
                                          pMasterKey.second.vchSalt,
                                          pMasterKey.second.nDeriveIterations,
                                          pMasterKey.second.nDerivationMethod);
             pMasterKey.second.nDeriveIterations = static_cast<unsigned int>(
                 pMasterKey.second.nDeriveIterations *
                 (100 / ((double)(GetTimeMillis() - nStartTime))));
 
             nStartTime = GetTimeMillis();
             crypter.SetKeyFromPassphrase(strNewWalletPassphrase,
                                          pMasterKey.second.vchSalt,
                                          pMasterKey.second.nDeriveIterations,
                                          pMasterKey.second.nDerivationMethod);
             pMasterKey.second.nDeriveIterations =
                 (pMasterKey.second.nDeriveIterations +
                  static_cast<unsigned int>(
                      pMasterKey.second.nDeriveIterations * 100 /
                      double(GetTimeMillis() - nStartTime))) /
                 2;
 
             if (pMasterKey.second.nDeriveIterations < 25000) {
                 pMasterKey.second.nDeriveIterations = 25000;
             }
 
             WalletLogPrintf(
                 "Wallet passphrase changed to an nDeriveIterations of %i\n",
                 pMasterKey.second.nDeriveIterations);
 
             if (!crypter.SetKeyFromPassphrase(
                     strNewWalletPassphrase, pMasterKey.second.vchSalt,
                     pMasterKey.second.nDeriveIterations,
                     pMasterKey.second.nDerivationMethod)) {
                 return false;
             }
 
             if (!crypter.Encrypt(_vMasterKey,
                                  pMasterKey.second.vchCryptedKey)) {
                 return false;
             }
 
             WalletBatch(*database).WriteMasterKey(pMasterKey.first,
                                                   pMasterKey.second);
             if (fWasLocked) {
                 Lock();
             }
 
             return true;
         }
     }
 
     return false;
 }
 
 void CWallet::chainStateFlushed(const CBlockLocator &loc) {
     WalletBatch batch(*database);
     batch.WriteBestBlock(loc);
 }
 
 void CWallet::SetMinVersion(enum WalletFeature nVersion, WalletBatch *batch_in,
                             bool fExplicit) {
     LOCK(cs_wallet);
     if (nWalletVersion >= nVersion) {
         return;
     }
 
     // When doing an explicit upgrade, if we pass the max version permitted,
     // upgrade all the way.
     if (fExplicit && nVersion > nWalletMaxVersion) {
         nVersion = FEATURE_LATEST;
     }
 
     nWalletVersion = nVersion;
 
     if (nVersion > nWalletMaxVersion) {
         nWalletMaxVersion = nVersion;
     }
 
     WalletBatch *batch = batch_in ? batch_in : new WalletBatch(*database);
     if (nWalletVersion > 40000) {
         batch->WriteMinVersion(nWalletVersion);
     }
     if (!batch_in) {
         delete batch;
     }
 }
 
 bool CWallet::SetMaxVersion(int nVersion) {
     LOCK(cs_wallet);
 
     // Cannot downgrade below current version
     if (nWalletVersion > nVersion) {
         return false;
     }
 
     nWalletMaxVersion = nVersion;
 
     return true;
 }
 
 std::set<TxId> CWallet::GetConflicts(const TxId &txid) const {
     std::set<TxId> result;
     AssertLockHeld(cs_wallet);
 
     std::map<TxId, CWalletTx>::const_iterator it = mapWallet.find(txid);
     if (it == mapWallet.end()) {
         return result;
     }
 
     const CWalletTx &wtx = it->second;
 
     std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
 
     for (const CTxIn &txin : wtx.tx->vin) {
         if (mapTxSpends.count(txin.prevout) <= 1) {
             // No conflict if zero or one spends.
             continue;
         }
 
         range = mapTxSpends.equal_range(txin.prevout);
         for (TxSpends::const_iterator _it = range.first; _it != range.second;
              ++_it) {
             result.insert(_it->second);
         }
     }
 
     return result;
 }
 
 bool CWallet::HasWalletSpend(const TxId &txid) const {
     AssertLockHeld(cs_wallet);
     auto iter = mapTxSpends.lower_bound(COutPoint(txid, 0));
     return (iter != mapTxSpends.end() && iter->first.GetTxId() == txid);
 }
 
 void CWallet::Flush(bool shutdown) {
     database->Flush(shutdown);
 }
 
 void CWallet::SyncMetaData(
     std::pair<TxSpends::iterator, TxSpends::iterator> range) {
     // We want all the wallet transactions in range to have the same metadata as
     // the oldest (smallest nOrderPos).
     // So: find smallest nOrderPos:
 
     int nMinOrderPos = std::numeric_limits<int>::max();
     const CWalletTx *copyFrom = nullptr;
     for (TxSpends::iterator it = range.first; it != range.second; ++it) {
         const CWalletTx *wtx = &mapWallet.at(it->second);
         if (wtx->nOrderPos < nMinOrderPos) {
             nMinOrderPos = wtx->nOrderPos;
             copyFrom = wtx;
         }
     }
 
     if (!copyFrom) {
         return;
     }
 
     // Now copy data from copyFrom to rest:
     for (TxSpends::iterator it = range.first; it != range.second; ++it) {
         const TxId &txid = it->second;
         CWalletTx *copyTo = &mapWallet.at(txid);
         if (copyFrom == copyTo) {
             continue;
         }
 
         assert(
             copyFrom &&
             "Oldest wallet transaction in range assumed to have been found.");
 
         if (!copyFrom->IsEquivalentTo(*copyTo)) {
             continue;
         }
 
         copyTo->mapValue = copyFrom->mapValue;
         copyTo->vOrderForm = copyFrom->vOrderForm;
         // fTimeReceivedIsTxTime not copied on purpose nTimeReceived not copied
         // on purpose.
         copyTo->nTimeSmart = copyFrom->nTimeSmart;
         copyTo->fFromMe = copyFrom->fFromMe;
         // nOrderPos not copied on purpose cached members not copied on purpose.
     }
 }
 
 /**
  * Outpoint is spent if any non-conflicted transaction, spends it:
  */
 bool CWallet::IsSpent(const COutPoint &outpoint) const {
     std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range =
         mapTxSpends.equal_range(outpoint);
 
     for (TxSpends::const_iterator it = range.first; it != range.second; ++it) {
         const TxId &wtxid = it->second;
         std::map<TxId, CWalletTx>::const_iterator mit = mapWallet.find(wtxid);
         if (mit != mapWallet.end()) {
             int depth = mit->second.GetDepthInMainChain();
             if (depth > 0 || (depth == 0 && !mit->second.isAbandoned())) {
                 // Spent
                 return true;
             }
         }
     }
 
     return false;
 }
 
 void CWallet::AddToSpends(const COutPoint &outpoint, const TxId &wtxid) {
     mapTxSpends.insert(std::make_pair(outpoint, wtxid));
 
     setLockedCoins.erase(outpoint);
 
     std::pair<TxSpends::iterator, TxSpends::iterator> range;
     range = mapTxSpends.equal_range(outpoint);
     SyncMetaData(range);
 }
 
 void CWallet::AddToSpends(const TxId &wtxid) {
     auto it = mapWallet.find(wtxid);
     assert(it != mapWallet.end());
     CWalletTx &thisTx = it->second;
     // Coinbases don't spend anything!
     if (thisTx.IsCoinBase()) {
         return;
     }
 
     for (const CTxIn &txin : thisTx.tx->vin) {
         AddToSpends(txin.prevout, wtxid);
     }
 }
 
 bool CWallet::EncryptWallet(const SecureString &strWalletPassphrase) {
     if (IsCrypted()) {
         return false;
     }
 
     CKeyingMaterial _vMasterKey;
 
     _vMasterKey.resize(WALLET_CRYPTO_KEY_SIZE);
     GetStrongRandBytes(&_vMasterKey[0], WALLET_CRYPTO_KEY_SIZE);
 
     CMasterKey kMasterKey;
 
     kMasterKey.vchSalt.resize(WALLET_CRYPTO_SALT_SIZE);
     GetStrongRandBytes(&kMasterKey.vchSalt[0], WALLET_CRYPTO_SALT_SIZE);
 
     CCrypter crypter;
     int64_t nStartTime = GetTimeMillis();
     crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, 25000,
                                  kMasterKey.nDerivationMethod);
     kMasterKey.nDeriveIterations = static_cast<unsigned int>(
         2500000 / double(GetTimeMillis() - nStartTime));
 
     nStartTime = GetTimeMillis();
     crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt,
                                  kMasterKey.nDeriveIterations,
                                  kMasterKey.nDerivationMethod);
     kMasterKey.nDeriveIterations =
         (kMasterKey.nDeriveIterations +
          static_cast<unsigned int>(kMasterKey.nDeriveIterations * 100 /
                                    double(GetTimeMillis() - nStartTime))) /
         2;
 
     if (kMasterKey.nDeriveIterations < 25000) {
         kMasterKey.nDeriveIterations = 25000;
     }
 
     WalletLogPrintf("Encrypting Wallet with an nDeriveIterations of %i\n",
                     kMasterKey.nDeriveIterations);
 
     if (!crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt,
                                       kMasterKey.nDeriveIterations,
                                       kMasterKey.nDerivationMethod)) {
         return false;
     }
 
     if (!crypter.Encrypt(_vMasterKey, kMasterKey.vchCryptedKey)) {
         return false;
     }
 
     {
         LOCK(cs_wallet);
         mapMasterKeys[++nMasterKeyMaxID] = kMasterKey;
         WalletBatch *encrypted_batch = new WalletBatch(*database);
         if (!encrypted_batch->TxnBegin()) {
             delete encrypted_batch;
             encrypted_batch = nullptr;
             return false;
         }
         encrypted_batch->WriteMasterKey(nMasterKeyMaxID, kMasterKey);
 
         for (const auto &spk_man_pair : m_spk_managers) {
             auto spk_man = spk_man_pair.second.get();
             if (!spk_man->Encrypt(_vMasterKey, encrypted_batch)) {
                 encrypted_batch->TxnAbort();
                 delete encrypted_batch;
                 encrypted_batch = nullptr;
                 // We now probably have half of our keys encrypted in memory,
                 // and half not... die and let the user reload the unencrypted
                 // wallet.
                 assert(false);
             }
         }
 
         // Encryption was introduced in version 0.4.0
         SetMinVersion(FEATURE_WALLETCRYPT, encrypted_batch, true);
 
         if (!encrypted_batch->TxnCommit()) {
             delete encrypted_batch;
             encrypted_batch = nullptr;
             // We now have keys encrypted in memory, but not on disk...
             // die to avoid confusion and let the user reload the unencrypted
             // wallet.
             assert(false);
         }
 
         delete encrypted_batch;
         encrypted_batch = nullptr;
 
         Lock();
         Unlock(strWalletPassphrase);
 
         // If we are using descriptors, make new descriptors with a new seed
         if (IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS) &&
             !IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET)) {
             SetupDescriptorScriptPubKeyMans();
         } else if (auto spk_man = GetLegacyScriptPubKeyMan()) {
             // if we are using HD, replace the HD seed with a new one
             if (spk_man->IsHDEnabled()) {
                 if (!spk_man->SetupGeneration(true)) {
                     return false;
                 }
             }
         }
         Lock();
 
         // Need to completely rewrite the wallet file; if we don't, bdb might
         // keep bits of the unencrypted private key in slack space in the
         // database file.
         database->Rewrite();
 
         // BDB seems to have a bad habit of writing old data into
         // slack space in .dat files; that is bad if the old data is
         // unencrypted private keys. So:
         database->ReloadDbEnv();
     }
 
     NotifyStatusChanged(this);
     return true;
 }
 
 DBErrors CWallet::ReorderTransactions() {
     LOCK(cs_wallet);
     WalletBatch batch(*database);
 
     // Old wallets didn't have any defined order for transactions. Probably a
     // bad idea to change the output of this.
 
     // First: get all CWalletTx into a sorted-by-time
     // multimap.
     TxItems txByTime;
 
     for (auto &entry : mapWallet) {
         CWalletTx *wtx = &entry.second;
         txByTime.insert(std::make_pair(wtx->nTimeReceived, wtx));
     }
 
     nOrderPosNext = 0;
     std::vector<int64_t> nOrderPosOffsets;
     for (TxItems::iterator it = txByTime.begin(); it != txByTime.end(); ++it) {
         CWalletTx *const pwtx = (*it).second;
         int64_t &nOrderPos = pwtx->nOrderPos;
 
         if (nOrderPos == -1) {
             nOrderPos = nOrderPosNext++;
             nOrderPosOffsets.push_back(nOrderPos);
 
             if (!batch.WriteTx(*pwtx)) {
                 return DBErrors::LOAD_FAIL;
             }
         } else {
             int64_t nOrderPosOff = 0;
             for (const int64_t &nOffsetStart : nOrderPosOffsets) {
                 if (nOrderPos >= nOffsetStart) {
                     ++nOrderPosOff;
                 }
             }
 
             nOrderPos += nOrderPosOff;
             nOrderPosNext = std::max(nOrderPosNext, nOrderPos + 1);
 
             if (!nOrderPosOff) {
                 continue;
             }
 
             // Since we're changing the order, write it back.
             if (!batch.WriteTx(*pwtx)) {
                 return DBErrors::LOAD_FAIL;
             }
         }
     }
 
     batch.WriteOrderPosNext(nOrderPosNext);
 
     return DBErrors::LOAD_OK;
 }
 
 int64_t CWallet::IncOrderPosNext(WalletBatch *batch) {
     AssertLockHeld(cs_wallet);
     int64_t nRet = nOrderPosNext++;
     if (batch) {
         batch->WriteOrderPosNext(nOrderPosNext);
     } else {
         WalletBatch(*database).WriteOrderPosNext(nOrderPosNext);
     }
 
     return nRet;
 }
 
 void CWallet::MarkDirty() {
     LOCK(cs_wallet);
     for (std::pair<const TxId, CWalletTx> &item : mapWallet) {
         item.second.MarkDirty();
     }
 }
 
 void CWallet::SetSpentKeyState(WalletBatch &batch, const TxId &txid,
                                unsigned int n, bool used,
                                std::set<CTxDestination> &tx_destinations) {
     AssertLockHeld(cs_wallet);
     const CWalletTx *srctx = GetWalletTx(txid);
     if (!srctx) {
         return;
     }
 
     CTxDestination dst;
     if (ExtractDestination(srctx->tx->vout[n].scriptPubKey, dst)) {
         if (IsMine(dst)) {
             if (used && !GetDestData(dst, "used", nullptr)) {
                 // p for "present", opposite of absent (null)
                 if (AddDestData(batch, dst, "used", "p")) {
                     tx_destinations.insert(dst);
                 }
             } else if (!used && GetDestData(dst, "used", nullptr)) {
                 EraseDestData(batch, dst, "used");
             }
         }
     }
 }
 
 bool CWallet::IsSpentKey(const TxId &txid, unsigned int n) const {
     AssertLockHeld(cs_wallet);
     CTxDestination dst;
     const CWalletTx *srctx = GetWalletTx(txid);
     if (srctx) {
         assert(srctx->tx->vout.size() > n);
         CTxDestination dest;
         if (!ExtractDestination(srctx->tx->vout[n].scriptPubKey, dest)) {
             return false;
         }
         if (GetDestData(dest, "used", nullptr)) {
             return true;
         }
         if (IsLegacy()) {
             LegacyScriptPubKeyMan *spk_man = GetLegacyScriptPubKeyMan();
             assert(spk_man != nullptr);
             for (const auto &keyid :
                  GetAffectedKeys(srctx->tx->vout[n].scriptPubKey, *spk_man)) {
                 PKHash pkh_dest(keyid);
                 if (GetDestData(pkh_dest, "used", nullptr)) {
                     return true;
                 }
             }
         }
     }
     return false;
 }
 
 CWalletTx *CWallet::AddToWallet(CTransactionRef tx,
                                 const CWalletTx::Confirmation &confirm,
                                 const UpdateWalletTxFn &update_wtx,
                                 bool fFlushOnClose) {
     LOCK(cs_wallet);
 
     WalletBatch batch(*database, "r+", fFlushOnClose);
 
     const TxId &txid = tx->GetId();
 
     if (IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE)) {
         // Mark used destinations
         std::set<CTxDestination> tx_destinations;
 
         for (const CTxIn &txin : tx->vin) {
             const COutPoint &op = txin.prevout;
             SetSpentKeyState(batch, op.GetTxId(), op.GetN(), true,
                              tx_destinations);
         }
 
         MarkDestinationsDirty(tx_destinations);
     }
 
     // Inserts only if not already there, returns tx inserted or tx found.
     auto ret =
         mapWallet.emplace(std::piecewise_construct, std::forward_as_tuple(txid),
                           std::forward_as_tuple(this, tx));
     CWalletTx &wtx = (*ret.first).second;
     bool fInsertedNew = ret.second;
     bool fUpdated = update_wtx && update_wtx(wtx, fInsertedNew);
     if (fInsertedNew) {
         wtx.m_confirm = confirm;
         wtx.nTimeReceived = chain().getAdjustedTime();
         wtx.nOrderPos = IncOrderPosNext(&batch);
         wtx.m_it_wtxOrdered =
             wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));
         wtx.nTimeSmart = ComputeTimeSmart(wtx);
         AddToSpends(txid);
     }
 
     if (!fInsertedNew) {
         if (confirm.status != wtx.m_confirm.status) {
             wtx.m_confirm.status = confirm.status;
             wtx.m_confirm.nIndex = confirm.nIndex;
             wtx.m_confirm.hashBlock = confirm.hashBlock;
             wtx.m_confirm.block_height = confirm.block_height;
             fUpdated = true;
         } else {
             assert(wtx.m_confirm.nIndex == confirm.nIndex);
             assert(wtx.m_confirm.hashBlock == confirm.hashBlock);
             assert(wtx.m_confirm.block_height == confirm.block_height);
         }
     }
 
     //// debug print
     WalletLogPrintf("AddToWallet %s  %s%s\n", txid.ToString(),
                     (fInsertedNew ? "new" : ""), (fUpdated ? "update" : ""));
 
     // Write to disk
     if ((fInsertedNew || fUpdated) && !batch.WriteTx(wtx)) {
         return nullptr;
     }
 
     // Break debit/credit balance caches:
     wtx.MarkDirty();
 
     // Notify UI of new or updated transaction.
     NotifyTransactionChanged(this, txid, fInsertedNew ? CT_NEW : CT_UPDATED);
 
 #if defined(HAVE_SYSTEM)
     // Notify an external script when a wallet transaction comes in or is
     // updated.
     std::string strCmd = gArgs.GetArg("-walletnotify", "");
 
     if (!strCmd.empty()) {
         boost::replace_all(strCmd, "%s", txid.GetHex());
 #ifndef WIN32
         // Substituting the wallet name isn't currently supported on windows
         // because windows shell escaping has not been implemented yet:
         // https://github.com/bitcoin/bitcoin/pull/13339#issuecomment-537384875
         // A few ways it could be implemented in the future are described in:
         // https://github.com/bitcoin/bitcoin/pull/13339#issuecomment-461288094
         boost::replace_all(strCmd, "%w", ShellEscape(GetName()));
 #endif
 
         std::thread t(runCommand, strCmd);
         // Thread runs free.
         t.detach();
     }
 #endif
 
     return &wtx;
 }
 
 bool CWallet::LoadToWallet(const TxId &txid, const UpdateWalletTxFn &fill_wtx) {
     const auto &ins =
         mapWallet.emplace(std::piecewise_construct, std::forward_as_tuple(txid),
                           std::forward_as_tuple(this, nullptr));
     CWalletTx &wtx = ins.first->second;
     if (!fill_wtx(wtx, ins.second)) {
         return false;
     }
     // If wallet doesn't have a chain (e.g wallet-tool), don't bother to update
     // txn.
     if (HaveChain()) {
         std::optional<int> block_height =
             chain().getBlockHeight(wtx.m_confirm.hashBlock);
         if (block_height) {
             // Update cached block height variable since it not stored in the
             // serialized transaction.
             wtx.m_confirm.block_height = *block_height;
         } else if (wtx.isConflicted() || wtx.isConfirmed()) {
             // If tx block (or conflicting block) was reorged out of chain
             // while the wallet was shutdown, change tx status to UNCONFIRMED
             // and reset block height, hash, and index. ABANDONED tx don't have
             // associated blocks and don't need to be updated. The case where a
             // transaction was reorged out while online and then reconfirmed
             // while offline is covered by the rescan logic.
             wtx.setUnconfirmed();
             wtx.m_confirm.hashBlock = BlockHash();
             wtx.m_confirm.block_height = 0;
             wtx.m_confirm.nIndex = 0;
         }
     }
     if (/* insertion took place */ ins.second) {
         wtx.m_it_wtxOrdered =
             wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));
     }
     AddToSpends(txid);
     for (const CTxIn &txin : wtx.tx->vin) {
         auto it = mapWallet.find(txin.prevout.GetTxId());
         if (it != mapWallet.end()) {
             CWalletTx &prevtx = it->second;
             if (prevtx.isConflicted()) {
                 MarkConflicted(prevtx.m_confirm.hashBlock,
                                prevtx.m_confirm.block_height, wtx.GetId());
             }
         }
     }
     return true;
 }
 
 bool CWallet::AddToWalletIfInvolvingMe(const CTransactionRef &ptx,
                                        CWalletTx::Confirmation confirm,
                                        bool fUpdate) {
     const CTransaction &tx = *ptx;
     AssertLockHeld(cs_wallet);
 
     if (!confirm.hashBlock.IsNull()) {
         for (const CTxIn &txin : tx.vin) {
             std::pair<TxSpends::const_iterator, TxSpends::const_iterator>
                 range = mapTxSpends.equal_range(txin.prevout);
             while (range.first != range.second) {
                 if (range.first->second != tx.GetId()) {
                     WalletLogPrintf(
                         "Transaction %s (in block %s) conflicts with wallet "
                         "transaction %s (both spend %s:%i)\n",
                         tx.GetId().ToString(), confirm.hashBlock.ToString(),
                         range.first->second.ToString(),
                         range.first->first.GetTxId().ToString(),
                         range.first->first.GetN());
                     MarkConflicted(confirm.hashBlock, confirm.block_height,
                                    range.first->second);
                 }
                 range.first++;
             }
         }
     }
 
     bool fExisted = mapWallet.count(tx.GetId()) != 0;
     if (fExisted && !fUpdate) {
         return false;
     }
     if (fExisted || IsMine(tx) || IsFromMe(tx)) {
         /**
          * Check if any keys in the wallet keypool that were supposed to be
          * unused have appeared in a new transaction. If so, remove those keys
          * from the keypool. This can happen when restoring an old wallet backup
          * that does not contain the mostly recently created transactions from
          * newer versions of the wallet.
          */
 
         // loop though all outputs
         for (const CTxOut &txout : tx.vout) {
             for (const auto &spk_man_pair : m_spk_managers) {
                 spk_man_pair.second->MarkUnusedAddresses(txout.scriptPubKey);
             }
         }
 
         // Block disconnection override an abandoned tx as unconfirmed
         // which means user may have to call abandontransaction again
         return AddToWallet(MakeTransactionRef(tx), confirm,
                            /* update_wtx= */ nullptr,
                            /* fFlushOnClose= */ false);
     }
     return false;
 }
 
 bool CWallet::TransactionCanBeAbandoned(const TxId &txid) const {
     LOCK(cs_wallet);
     const CWalletTx *wtx = GetWalletTx(txid);
     return wtx && !wtx->isAbandoned() && wtx->GetDepthInMainChain() == 0 &&
            !wtx->InMempool();
 }
 
 void CWallet::MarkInputsDirty(const CTransactionRef &tx) {
     for (const CTxIn &txin : tx->vin) {
         auto it = mapWallet.find(txin.prevout.GetTxId());
         if (it != mapWallet.end()) {
             it->second.MarkDirty();
         }
     }
 }
 
 bool CWallet::AbandonTransaction(const TxId &txid) {
     LOCK(cs_wallet);
 
     WalletBatch batch(*database, "r+");
 
     std::set<TxId> todo;
     std::set<TxId> done;
 
     // Can't mark abandoned if confirmed or in mempool
     auto it = mapWallet.find(txid);
     assert(it != mapWallet.end());
     CWalletTx &origtx = it->second;
     if (origtx.GetDepthInMainChain() != 0 || origtx.InMempool()) {
         return false;
     }
 
     todo.insert(txid);
 
     while (!todo.empty()) {
         const TxId now = *todo.begin();
         todo.erase(now);
         done.insert(now);
         it = mapWallet.find(now);
         assert(it != mapWallet.end());
         CWalletTx &wtx = it->second;
         int currentconfirm = wtx.GetDepthInMainChain();
         // If the orig tx was not in block, none of its spends can be.
         assert(currentconfirm <= 0);
         // If (currentconfirm < 0) {Tx and spends are already conflicted, no
         // need to abandon}
         if (currentconfirm == 0 && !wtx.isAbandoned()) {
             // If the orig tx was not in block/mempool, none of its spends can
             // be in mempool.
             assert(!wtx.InMempool());
             wtx.setAbandoned();
             wtx.MarkDirty();
             batch.WriteTx(wtx);
             NotifyTransactionChanged(this, wtx.GetId(), CT_UPDATED);
             // Iterate over all its outputs, and mark transactions in the wallet
             // that spend them abandoned too.
             TxSpends::const_iterator iter =
                 mapTxSpends.lower_bound(COutPoint(now, 0));
             while (iter != mapTxSpends.end() && iter->first.GetTxId() == now) {
                 if (!done.count(iter->second)) {
                     todo.insert(iter->second);
                 }
                 iter++;
             }
 
             // If a transaction changes 'conflicted' state, that changes the
             // balance available of the outputs it spends. So force those to be
             // recomputed.
             MarkInputsDirty(wtx.tx);
         }
     }
 
     return true;
 }
 
 void CWallet::MarkConflicted(const BlockHash &hashBlock, int conflicting_height,
                              const TxId &txid) {
     LOCK(cs_wallet);
 
     int conflictconfirms =
         (m_last_block_processed_height - conflicting_height + 1) * -1;
 
     // If number of conflict confirms cannot be determined, this means that the
     // block is still unknown or not yet part of the main chain, for example
     // when loading the wallet during a reindex. Do nothing in that case.
     if (conflictconfirms >= 0) {
         return;
     }
 
     // Do not flush the wallet here for performance reasons.
     WalletBatch batch(*database, "r+", false);
 
     std::set<TxId> todo;
     std::set<TxId> done;
 
     todo.insert(txid);
 
     while (!todo.empty()) {
         const TxId now = *todo.begin();
         todo.erase(now);
         done.insert(now);
         auto it = mapWallet.find(now);
         assert(it != mapWallet.end());
         CWalletTx &wtx = it->second;
         int currentconfirm = wtx.GetDepthInMainChain();
         if (conflictconfirms < currentconfirm) {
             // Block is 'more conflicted' than current confirm; update.
             // Mark transaction as conflicted with this block.
             wtx.m_confirm.nIndex = 0;
             wtx.m_confirm.hashBlock = hashBlock;
             wtx.m_confirm.block_height = conflicting_height;
             wtx.setConflicted();
             wtx.MarkDirty();
             batch.WriteTx(wtx);
             // Iterate over all its outputs, and mark transactions in the wallet
             // that spend them conflicted too.
             TxSpends::const_iterator iter =
                 mapTxSpends.lower_bound(COutPoint(now, 0));
             while (iter != mapTxSpends.end() && iter->first.GetTxId() == now) {
                 if (!done.count(iter->second)) {
                     todo.insert(iter->second);
                 }
                 iter++;
             }
             // If a transaction changes 'conflicted' state, that changes the
             // balance available of the outputs it spends. So force those to be
             // recomputed.
             MarkInputsDirty(wtx.tx);
         }
     }
 }
 
 void CWallet::SyncTransaction(const CTransactionRef &ptx,
                               CWalletTx::Confirmation confirm, bool update_tx) {
     if (!AddToWalletIfInvolvingMe(ptx, confirm, update_tx)) {
         // Not one of ours
         return;
     }
 
     // If a transaction changes 'conflicted' state, that changes the balance
     // available of the outputs it spends. So force those to be
     // recomputed, also:
     MarkInputsDirty(ptx);
 }
 
 void CWallet::transactionAddedToMempool(const CTransactionRef &ptx) {
     LOCK(cs_wallet);
     CWalletTx::Confirmation confirm(CWalletTx::Status::UNCONFIRMED,
                                     /* block_height */ 0, BlockHash(),
                                     /* nIndex */ 0);
     SyncTransaction(ptx, confirm);
 
     auto it = mapWallet.find(ptx->GetId());
     if (it != mapWallet.end()) {
         it->second.fInMempool = true;
     }
 }
 
 void CWallet::transactionRemovedFromMempool(const CTransactionRef &ptx) {
     LOCK(cs_wallet);
     auto it = mapWallet.find(ptx->GetId());
     if (it != mapWallet.end()) {
         it->second.fInMempool = false;
     }
 }
 
 void CWallet::blockConnected(const CBlock &block, int height) {
     const BlockHash &block_hash = block.GetHash();
     LOCK(cs_wallet);
 
     m_last_block_processed_height = height;
     m_last_block_processed = block_hash;
     for (size_t index = 0; index < block.vtx.size(); index++) {
         CWalletTx::Confirmation confirm(CWalletTx::Status::CONFIRMED, height,
                                         block_hash, index);
         SyncTransaction(block.vtx[index], confirm);
         transactionRemovedFromMempool(block.vtx[index]);
     }
 }
 
 void CWallet::blockDisconnected(const CBlock &block, int height) {
     LOCK(cs_wallet);
 
     // At block disconnection, this will change an abandoned transaction to
     // be unconfirmed, whether or not the transaction is added back to the
     // mempool. User may have to call abandontransaction again. It may be
     // addressed in the future with a stickier abandoned state or even removing
     // abandontransaction call.
     m_last_block_processed_height = height - 1;
     m_last_block_processed = block.hashPrevBlock;
     for (const CTransactionRef &ptx : block.vtx) {
         CWalletTx::Confirmation confirm(CWalletTx::Status::UNCONFIRMED,
                                         /* block_height */ 0, BlockHash(),
                                         /* nIndex */ 0);
         SyncTransaction(ptx, confirm);
     }
 }
 
 void CWallet::updatedBlockTip() {
     m_best_block_time = GetTime();
 }
 
 void CWallet::BlockUntilSyncedToCurrentChain() const {
     AssertLockNotHeld(cs_wallet);
     // Skip the queue-draining stuff if we know we're caught up with
     // chainActive.Tip(), otherwise put a callback in the validation interface
     // queue and wait for the queue to drain enough to execute it (indicating we
     // are caught up at least with the time we entered this function).
     const BlockHash last_block_hash =
         WITH_LOCK(cs_wallet, return m_last_block_processed);
     chain().waitForNotificationsIfTipChanged(last_block_hash);
 }
 
 isminetype CWallet::IsMine(const CTxIn &txin) const {
     LOCK(cs_wallet);
     std::map<TxId, CWalletTx>::const_iterator mi =
         mapWallet.find(txin.prevout.GetTxId());
     if (mi != mapWallet.end()) {
         const CWalletTx &prev = (*mi).second;
         if (txin.prevout.GetN() < prev.tx->vout.size()) {
             return IsMine(prev.tx->vout[txin.prevout.GetN()]);
         }
     }
 
     return ISMINE_NO;
 }
 
 // Note that this function doesn't distinguish between a 0-valued input, and a
 // not-"is mine" (according to the filter) input.
 Amount CWallet::GetDebit(const CTxIn &txin, const isminefilter &filter) const {
     LOCK(cs_wallet);
     std::map<TxId, CWalletTx>::const_iterator mi =
         mapWallet.find(txin.prevout.GetTxId());
     if (mi != mapWallet.end()) {
         const CWalletTx &prev = (*mi).second;
         if (txin.prevout.GetN() < prev.tx->vout.size()) {
             if (IsMine(prev.tx->vout[txin.prevout.GetN()]) & filter) {
                 return prev.tx->vout[txin.prevout.GetN()].nValue;
             }
         }
     }
 
     return Amount::zero();
 }
 
 isminetype CWallet::IsMine(const CTxOut &txout) const {
     return IsMine(txout.scriptPubKey);
 }
 
 isminetype CWallet::IsMine(const CTxDestination &dest) const {
     return IsMine(GetScriptForDestination(dest));
 }
 
 isminetype CWallet::IsMine(const CScript &script) const {
     isminetype result = ISMINE_NO;
     for (const auto &spk_man_pair : m_spk_managers) {
         result = std::max(result, spk_man_pair.second->IsMine(script));
     }
     return result;
 }
 
 Amount CWallet::GetCredit(const CTxOut &txout,
                           const isminefilter &filter) const {
     if (!MoneyRange(txout.nValue)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": value out of range");
     }
 
     return (IsMine(txout) & filter) ? txout.nValue : Amount::zero();
 }
 
 bool CWallet::IsChange(const CTxOut &txout) const {
     return IsChange(txout.scriptPubKey);
 }
 
 bool CWallet::IsChange(const CScript &script) const {
     // TODO: fix handling of 'change' outputs. The assumption is that any
     // payment to a script that is ours, but is not in the address book is
     // change. That assumption is likely to break when we implement
     // multisignature wallets that return change back into a
     // multi-signature-protected address; a better way of identifying which
     // outputs are 'the send' and which are 'the change' will need to be
     // implemented (maybe extend CWalletTx to remember which output, if any, was
     // change).
     if (IsMine(script)) {
         CTxDestination address;
         if (!ExtractDestination(script, address)) {
             return true;
         }
 
         LOCK(cs_wallet);
         if (!FindAddressBookEntry(address)) {
             return true;
         }
     }
 
     return false;
 }
 
 Amount CWallet::GetChange(const CTxOut &txout) const {
     if (!MoneyRange(txout.nValue)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": value out of range");
     }
 
     return (IsChange(txout) ? txout.nValue : Amount::zero());
 }
 
 bool CWallet::IsMine(const CTransaction &tx) const {
     for (const CTxOut &txout : tx.vout) {
         if (IsMine(txout)) {
             return true;
         }
     }
 
     return false;
 }
 
 bool CWallet::IsFromMe(const CTransaction &tx) const {
     return GetDebit(tx, ISMINE_ALL) > Amount::zero();
 }
 
 Amount CWallet::GetDebit(const CTransaction &tx,
                          const isminefilter &filter) const {
     Amount nDebit = Amount::zero();
     for (const CTxIn &txin : tx.vin) {
         nDebit += GetDebit(txin, filter);
         if (!MoneyRange(nDebit)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": value out of range");
         }
     }
 
     return nDebit;
 }
 
 bool CWallet::IsAllFromMe(const CTransaction &tx,
                           const isminefilter &filter) const {
     LOCK(cs_wallet);
 
     for (const CTxIn &txin : tx.vin) {
         auto mi = mapWallet.find(txin.prevout.GetTxId());
         if (mi == mapWallet.end()) {
             // Any unknown inputs can't be from us.
             return false;
         }
 
         const CWalletTx &prev = (*mi).second;
 
         if (txin.prevout.GetN() >= prev.tx->vout.size()) {
             // Invalid input!
             return false;
         }
 
         if (!(IsMine(prev.tx->vout[txin.prevout.GetN()]) & filter)) {
             return false;
         }
     }
 
     return true;
 }
 
 Amount CWallet::GetCredit(const CTransaction &tx,
                           const isminefilter &filter) const {
     Amount nCredit = Amount::zero();
     for (const CTxOut &txout : tx.vout) {
         nCredit += GetCredit(txout, filter);
         if (!MoneyRange(nCredit)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": value out of range");
         }
     }
 
     return nCredit;
 }
 
 Amount CWallet::GetChange(const CTransaction &tx) const {
     Amount nChange = Amount::zero();
     for (const CTxOut &txout : tx.vout) {
         nChange += GetChange(txout);
         if (!MoneyRange(nChange)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": value out of range");
         }
     }
 
     return nChange;
 }
 
 bool CWallet::IsHDEnabled() const {
     // All Active ScriptPubKeyMans must be HD for this to be true
     bool result = true;
     for (const auto &spk_man : GetActiveScriptPubKeyMans()) {
         result &= spk_man->IsHDEnabled();
     }
     return result;
 }
 
 bool CWallet::CanGetAddresses(bool internal) const {
     LOCK(cs_wallet);
     if (m_spk_managers.empty()) {
         return false;
     }
     for (OutputType t : OUTPUT_TYPES) {
         auto spk_man = GetScriptPubKeyMan(t, internal);
         if (spk_man && spk_man->CanGetAddresses(internal)) {
             return true;
         }
     }
     return false;
 }
 
 void CWallet::SetWalletFlag(uint64_t flags) {
     LOCK(cs_wallet);
     m_wallet_flags |= flags;
     if (!WalletBatch(*database).WriteWalletFlags(m_wallet_flags)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing wallet flags failed");
     }
 }
 
 void CWallet::UnsetWalletFlag(uint64_t flag) {
     WalletBatch batch(*database);
     UnsetWalletFlagWithDB(batch, flag);
 }
 
 void CWallet::UnsetWalletFlagWithDB(WalletBatch &batch, uint64_t flag) {
     LOCK(cs_wallet);
     m_wallet_flags &= ~flag;
     if (!batch.WriteWalletFlags(m_wallet_flags)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing wallet flags failed");
     }
 }
 
 void CWallet::UnsetBlankWalletFlag(WalletBatch &batch) {
     UnsetWalletFlagWithDB(batch, WALLET_FLAG_BLANK_WALLET);
 }
 
 bool CWallet::IsWalletFlagSet(uint64_t flag) const {
     return (m_wallet_flags & flag);
 }
 
 bool CWallet::SetWalletFlags(uint64_t overwriteFlags, bool memonly) {
     LOCK(cs_wallet);
     m_wallet_flags = overwriteFlags;
     if (((overwriteFlags & KNOWN_WALLET_FLAGS) >> 32) ^
         (overwriteFlags >> 32)) {
         // contains unknown non-tolerable wallet flags
         return false;
     }
     if (!memonly && !WalletBatch(*database).WriteWalletFlags(m_wallet_flags)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing wallet flags failed");
     }
 
     return true;
 }
 
 int64_t CWalletTx::GetTxTime() const {
     int64_t n = nTimeSmart;
     return n ? n : nTimeReceived;
 }
 
 // Helper for producing a max-sized low-S low-R signature (eg 71 bytes)
 // or a max-sized low-S signature (e.g. 72 bytes) if use_max_sig is true
 bool CWallet::DummySignInput(CTxIn &tx_in, const CTxOut &txout,
                              bool use_max_sig) const {
     // Fill in dummy signatures for fee calculation.
     const CScript &scriptPubKey = txout.scriptPubKey;
     SignatureData sigdata;
 
     std::unique_ptr<SigningProvider> provider =
         GetSolvingProvider(scriptPubKey);
     if (!provider) {
         // We don't know about this scriptpbuKey;
         return false;
     }
 
     if (!ProduceSignature(*provider,
                           use_max_sig ? DUMMY_MAXIMUM_SIGNATURE_CREATOR
                                       : DUMMY_SIGNATURE_CREATOR,
                           scriptPubKey, sigdata)) {
         return false;
     }
 
     UpdateInput(tx_in, sigdata);
     return true;
 }
 
 // Helper for producing a bunch of max-sized low-S low-R signatures (eg 71
 // bytes)
 bool CWallet::DummySignTx(CMutableTransaction &txNew,
                           const std::vector<CTxOut> &txouts,
                           bool use_max_sig) const {
     // Fill in dummy signatures for fee calculation.
     int nIn = 0;
     for (const auto &txout : txouts) {
         if (!DummySignInput(txNew.vin[nIn], txout, use_max_sig)) {
             return false;
         }
 
         nIn++;
     }
     return true;
 }
 
 bool CWallet::ImportScripts(const std::set<CScript> scripts,
                             int64_t timestamp) {
     auto spk_man = GetLegacyScriptPubKeyMan();
     if (!spk_man) {
         return false;
     }
     LOCK(spk_man->cs_KeyStore);
     return spk_man->ImportScripts(scripts, timestamp);
 }
 
 bool CWallet::ImportPrivKeys(const std::map<CKeyID, CKey> &privkey_map,
                              const int64_t timestamp) {
     auto spk_man = GetLegacyScriptPubKeyMan();
     if (!spk_man) {
         return false;
     }
     LOCK(spk_man->cs_KeyStore);
     return spk_man->ImportPrivKeys(privkey_map, timestamp);
 }
 
 bool CWallet::ImportPubKeys(
     const std::vector<CKeyID> &ordered_pubkeys,
     const std::map<CKeyID, CPubKey> &pubkey_map,
     const std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>> &key_origins,
     const bool add_keypool, const bool internal, const int64_t timestamp) {
     auto spk_man = GetLegacyScriptPubKeyMan();
     if (!spk_man) {
         return false;
     }
     LOCK(spk_man->cs_KeyStore);
     return spk_man->ImportPubKeys(ordered_pubkeys, pubkey_map, key_origins,
                                   add_keypool, internal, timestamp);
 }
 
 bool CWallet::ImportScriptPubKeys(const std::string &label,
                                   const std::set<CScript> &script_pub_keys,
                                   const bool have_solving_data,
                                   const bool apply_label,
                                   const int64_t timestamp) {
     auto spk_man = GetLegacyScriptPubKeyMan();
     if (!spk_man) {
         return false;
     }
     LOCK(spk_man->cs_KeyStore);
     if (!spk_man->ImportScriptPubKeys(script_pub_keys, have_solving_data,
                                       timestamp)) {
         return false;
     }
     if (apply_label) {
         WalletBatch batch(*database);
         for (const CScript &script : script_pub_keys) {
             CTxDestination dest;
             ExtractDestination(script, dest);
             if (IsValidDestination(dest)) {
                 SetAddressBookWithDB(batch, dest, label, "receive");
             }
         }
     }
     return true;
 }
 
 int64_t CalculateMaximumSignedTxSize(const CTransaction &tx,
                                      const CWallet *wallet, bool use_max_sig) {
     std::vector<CTxOut> txouts;
     for (auto &input : tx.vin) {
         const auto mi = wallet->mapWallet.find(input.prevout.GetTxId());
         // Can not estimate size without knowing the input details
         if (mi == wallet->mapWallet.end()) {
             return -1;
         }
         assert(input.prevout.GetN() < mi->second.tx->vout.size());
         txouts.emplace_back(mi->second.tx->vout[input.prevout.GetN()]);
     }
     return CalculateMaximumSignedTxSize(tx, wallet, txouts, use_max_sig);
 }
 
 // txouts needs to be in the order of tx.vin
 int64_t CalculateMaximumSignedTxSize(const CTransaction &tx,
                                      const CWallet *wallet,
                                      const std::vector<CTxOut> &txouts,
                                      bool use_max_sig) {
     CMutableTransaction txNew(tx);
     if (!wallet->DummySignTx(txNew, txouts, use_max_sig)) {
         return -1;
     }
     return GetSerializeSize(txNew, PROTOCOL_VERSION);
 }
 
 int CalculateMaximumSignedInputSize(const CTxOut &txout, const CWallet *wallet,
                                     bool use_max_sig) {
     CMutableTransaction txn;
     txn.vin.push_back(CTxIn(COutPoint()));
     if (!wallet->DummySignInput(txn.vin[0], txout, use_max_sig)) {
         return -1;
     }
     return GetSerializeSize(txn.vin[0], PROTOCOL_VERSION);
 }
 
 void CWalletTx::GetAmounts(std::list<COutputEntry> &listReceived,
                            std::list<COutputEntry> &listSent, Amount &nFee,
                            const isminefilter &filter) const {
     nFee = Amount::zero();
     listReceived.clear();
     listSent.clear();
 
     // Compute fee:
     Amount nDebit = GetDebit(filter);
     // debit>0 means we signed/sent this transaction.
     if (nDebit > Amount::zero()) {
         Amount nValueOut = tx->GetValueOut();
         nFee = (nDebit - nValueOut);
     }
 
     // Sent/received.
     for (unsigned int i = 0; i < tx->vout.size(); ++i) {
         const CTxOut &txout = tx->vout[i];
         isminetype fIsMine = pwallet->IsMine(txout);
         // Only need to handle txouts if AT LEAST one of these is true:
         //   1) they debit from us (sent)
         //   2) the output is to us (received)
         if (nDebit > Amount::zero()) {
             // Don't report 'change' txouts
             if (pwallet->IsChange(txout)) {
                 continue;
             }
         } else if (!(fIsMine & filter)) {
             continue;
         }
 
         // In either case, we need to get the destination address.
         CTxDestination address;
 
         if (!ExtractDestination(txout.scriptPubKey, address) &&
             !txout.scriptPubKey.IsUnspendable()) {
             pwallet->WalletLogPrintf("CWalletTx::GetAmounts: Unknown "
                                      "transaction type found, txid %s\n",
                                      this->GetId().ToString());
             address = CNoDestination();
         }
 
         COutputEntry output = {address, txout.nValue, (int)i};
 
         // If we are debited by the transaction, add the output as a "sent"
         // entry.
         if (nDebit > Amount::zero()) {
             listSent.push_back(output);
         }
 
         // If we are receiving the output, add it as a "received" entry.
         if (fIsMine & filter) {
             listReceived.push_back(output);
         }
     }
 }
 
 /**
  * Scan active chain for relevant transactions after importing keys. This should
  * be called whenever new keys are added to the wallet, with the oldest key
  * creation time.
  *
  * @return Earliest timestamp that could be successfully scanned from. Timestamp
  * returned will be higher than startTime if relevant blocks could not be read.
  */
 int64_t CWallet::RescanFromTime(int64_t startTime,
                                 const WalletRescanReserver &reserver,
                                 bool update) {
     // Find starting block. May be null if nCreateTime is greater than the
     // highest blockchain timestamp, in which case there is nothing that needs
     // to be scanned.
     int start_height = 0;
     BlockHash start_block;
     bool start = chain().findFirstBlockWithTimeAndHeight(
         startTime - TIMESTAMP_WINDOW, 0,
         FoundBlock().hash(start_block).height(start_height));
     WalletLogPrintf("%s: Rescanning last %i blocks\n", __func__,
                     start ? WITH_LOCK(cs_wallet, return GetLastBlockHeight()) -
                                 start_height + 1
                           : 0);
 
     if (start) {
         // TODO: this should take into account failure by ScanResult::USER_ABORT
         ScanResult result = ScanForWalletTransactions(
             start_block, start_height, {} /* max_height */, reserver, update);
         if (result.status == ScanResult::FAILURE) {
             int64_t time_max;
             CHECK_NONFATAL(chain().findBlock(result.last_failed_block,
                                              FoundBlock().maxTime(time_max)));
             return time_max + TIMESTAMP_WINDOW + 1;
         }
     }
     return startTime;
 }
 
 /**
  * Scan the block chain (starting in start_block) for transactions from or to
  * us. If fUpdate is true, found transactions that already exist in the wallet
  * will be updated.
  *
  * @param[in] start_block Scan starting block. If block is not on the active
  *                        chain, the scan will return SUCCESS immediately.
  * @param[in] start_height Height of start_block
  * @param[in] max_height  Optional max scanning height. If unset there is
  *                        no maximum and scanning can continue to the tip
  *
  * @return ScanResult returning scan information and indicating success or
  *         failure. Return status will be set to SUCCESS if scan was
  *         successful. FAILURE if a complete rescan was not possible (due to
  *         pruning or corruption). USER_ABORT if the rescan was aborted before
  *         it could complete.
  *
  * @pre Caller needs to make sure start_block (and the optional stop_block) are
  * on the main chain after to the addition of any new keys you want to detect
  * transactions for.
  */
 CWallet::ScanResult CWallet::ScanForWalletTransactions(
     const BlockHash &start_block, int start_height,
     std::optional<int> max_height, const WalletRescanReserver &reserver,
     bool fUpdate) {
     int64_t nNow = GetTime();
     int64_t start_time = GetTimeMillis();
 
     assert(reserver.isReserved());
 
     BlockHash block_hash = start_block;
     ScanResult result;
 
     WalletLogPrintf("Rescan started from block %s...\n",
                     start_block.ToString());
 
     fAbortRescan = false;
     // Show rescan progress in GUI as dialog or on splashscreen, if -rescan on
     // startup.
     ShowProgress(
         strprintf("%s " + _("Rescanning...").translated, GetDisplayName()), 0);
     BlockHash tip_hash = WITH_LOCK(cs_wallet, return GetLastBlockHash());
     BlockHash end_hash = tip_hash;
     if (max_height) {
         chain().findAncestorByHeight(tip_hash, *max_height,
                                      FoundBlock().hash(end_hash));
     }
     double progress_begin = chain().guessVerificationProgress(block_hash);
     double progress_end = chain().guessVerificationProgress(end_hash);
     double progress_current = progress_begin;
     int block_height = start_height;
     while (!fAbortRescan && !chain().shutdownRequested()) {
         m_scanning_progress = (progress_current - progress_begin) /
                               (progress_end - progress_begin);
         if (block_height % 100 == 0 && progress_end - progress_begin > 0.0) {
             ShowProgress(
                 strprintf("%s " + _("Rescanning...").translated,
                           GetDisplayName()),
                 std::max(1, std::min(99, (int)(m_scanning_progress * 100))));
         }
         if (GetTime() >= nNow + 60) {
             nNow = GetTime();
             WalletLogPrintf("Still rescanning. At block %d. Progress=%f\n",
                             block_height, progress_current);
         }
 
         CBlock block;
         bool next_block;
         BlockHash next_block_hash;
         bool reorg = false;
         if (chain().findBlock(block_hash, FoundBlock().data(block)) &&
             !block.IsNull()) {
             LOCK(cs_wallet);
             next_block = chain().findNextBlock(
                 block_hash, block_height, FoundBlock().hash(next_block_hash),
                 &reorg);
             if (reorg) {
                 // Abort scan if current block is no longer active, to prevent
                 // marking transactions as coming from the wrong block.
                 // TODO: This should return success instead of failure, see
                 // https://github.com/bitcoin/bitcoin/pull/14711#issuecomment-458342518
                 result.last_failed_block = block_hash;
                 result.status = ScanResult::FAILURE;
                 break;
             }
             for (size_t posInBlock = 0; posInBlock < block.vtx.size();
                  ++posInBlock) {
                 CWalletTx::Confirmation confirm(CWalletTx::Status::CONFIRMED,
                                                 block_height, block_hash,
                                                 posInBlock);
                 SyncTransaction(block.vtx[posInBlock], confirm, fUpdate);
             }
             // scan succeeded, record block as most recent successfully
             // scanned
             result.last_scanned_block = block_hash;
             result.last_scanned_height = block_height;
         } else {
             // could not scan block, keep scanning but record this block as
             // the most recent failure
             result.last_failed_block = block_hash;
             result.status = ScanResult::FAILURE;
             next_block = chain().findNextBlock(
                 block_hash, block_height, FoundBlock().hash(next_block_hash),
                 &reorg);
         }
         if (max_height && block_height >= *max_height) {
             break;
         }
         {
             if (!next_block || reorg) {
                 // break successfully when rescan has reached the tip, or
                 // previous block is no longer on the chain due to a reorg
                 break;
             }
 
             // increment block and verification progress
             block_hash = next_block_hash;
             ++block_height;
             progress_current = chain().guessVerificationProgress(block_hash);
 
             // handle updated tip hash
             const BlockHash prev_tip_hash = tip_hash;
             tip_hash = WITH_LOCK(cs_wallet, return GetLastBlockHash());
             if (!max_height && prev_tip_hash != tip_hash) {
                 // in case the tip has changed, update progress max
                 progress_end = chain().guessVerificationProgress(tip_hash);
             }
         }
     }
 
     // Hide progress dialog in GUI.
     ShowProgress(
         strprintf("%s " + _("Rescanning...").translated, GetDisplayName()),
         100);
     if (block_height && fAbortRescan) {
         WalletLogPrintf("Rescan aborted at block %d. Progress=%f\n",
                         block_height, progress_current);
         result.status = ScanResult::USER_ABORT;
     } else if (block_height && chain().shutdownRequested()) {
         WalletLogPrintf(
             "Rescan interrupted by shutdown request at block %d. Progress=%f\n",
             block_height, progress_current);
         result.status = ScanResult::USER_ABORT;
     } else {
         WalletLogPrintf("Rescan completed in %15dms\n",
                         GetTimeMillis() - start_time);
     }
     return result;
 }
 
 void CWallet::ReacceptWalletTransactions() {
     // If transactions aren't being broadcasted, don't let them into local
     // mempool either.
     if (!fBroadcastTransactions) {
         return;
     }
 
     std::map<int64_t, CWalletTx *> mapSorted;
 
     // Sort pending wallet transactions based on their initial wallet insertion
     // order.
     for (std::pair<const TxId, CWalletTx> &item : mapWallet) {
         const TxId &wtxid = item.first;
         CWalletTx &wtx = item.second;
         assert(wtx.GetId() == wtxid);
 
         int nDepth = wtx.GetDepthInMainChain();
 
         if (!wtx.IsCoinBase() && (nDepth == 0 && !wtx.isAbandoned())) {
             mapSorted.insert(std::make_pair(wtx.nOrderPos, &wtx));
         }
     }
 
     // Try to add wallet transactions to memory pool.
     for (const std::pair<const int64_t, CWalletTx *> &item : mapSorted) {
         CWalletTx &wtx = *(item.second);
         std::string unused_err_string;
         wtx.SubmitMemoryPoolAndRelay(unused_err_string, false);
     }
 }
 
 bool CWalletTx::SubmitMemoryPoolAndRelay(std::string &err_string, bool relay) {
     // Can't relay if wallet is not broadcasting
     if (!pwallet->GetBroadcastTransactions()) {
         return false;
     }
     // Don't relay abandoned transactions
     if (isAbandoned()) {
         return false;
     }
     // Don't try to submit coinbase transactions. These would fail anyway but
     // would cause log spam.
     if (IsCoinBase()) {
         return false;
     }
     // Don't try to submit conflicted or confirmed transactions.
     if (GetDepthInMainChain() != 0) {
         return false;
     }
 
     // Submit transaction to mempool for relay
     pwallet->WalletLogPrintf("Submitting wtx %s to mempool for relay\n",
                              GetId().ToString());
     // We must set fInMempool here - while it will be re-set to true by the
     // entered-mempool callback, if we did not there would be a race where a
     // user could call sendmoney in a loop and hit spurious out of funds errors
     // because we think that this newly generated transaction's change is
     // unavailable as we're not yet aware that it is in the mempool.
     //
     // Irrespective of the failure reason, un-marking fInMempool
     // out-of-order is incorrect - it should be unmarked when
     // TransactionRemovedFromMempool fires.
     bool ret = pwallet->chain().broadcastTransaction(
         GetConfig(), tx, pwallet->m_default_max_tx_fee, relay, err_string);
     fInMempool |= ret;
     return ret;
 }
 
 std::set<TxId> CWalletTx::GetConflicts() const {
     std::set<TxId> result;
     if (pwallet != nullptr) {
         const TxId &txid = GetId();
         result = pwallet->GetConflicts(txid);
         result.erase(txid);
     }
 
     return result;
 }
 
 Amount CWalletTx::GetCachableAmount(AmountType type, const isminefilter &filter,
                                     bool recalculate) const {
     auto &amount = m_amounts[type];
     if (recalculate || !amount.m_cached[filter]) {
         amount.Set(filter, type == DEBIT ? pwallet->GetDebit(*tx, filter)
                                          : pwallet->GetCredit(*tx, filter));
         m_is_cache_empty = false;
     }
     return amount.m_value[filter];
 }
 
 Amount CWalletTx::GetDebit(const isminefilter &filter) const {
     if (tx->vin.empty()) {
         return Amount::zero();
     }
 
     Amount debit = Amount::zero();
     if (filter & ISMINE_SPENDABLE) {
         debit += GetCachableAmount(DEBIT, ISMINE_SPENDABLE);
     }
     if (filter & ISMINE_WATCH_ONLY) {
         debit += GetCachableAmount(DEBIT, ISMINE_WATCH_ONLY);
     }
 
     return debit;
 }
 
 Amount CWalletTx::GetCredit(const isminefilter &filter) const {
     // Must wait until coinbase is safely deep enough in the chain before
     // valuing it.
     if (IsImmatureCoinBase()) {
         return Amount::zero();
     }
 
     Amount credit = Amount::zero();
     if (filter & ISMINE_SPENDABLE) {
         // GetBalance can assume transactions in mapWallet won't change.
         credit += GetCachableAmount(CREDIT, ISMINE_SPENDABLE);
     }
 
     if (filter & ISMINE_WATCH_ONLY) {
         credit += GetCachableAmount(CREDIT, ISMINE_WATCH_ONLY);
     }
 
     return credit;
 }
 
 Amount CWalletTx::GetImmatureCredit(bool fUseCache) const {
     if (IsImmatureCoinBase() && IsInMainChain()) {
         return GetCachableAmount(IMMATURE_CREDIT, ISMINE_SPENDABLE, !fUseCache);
     }
 
     return Amount::zero();
 }
 
 Amount CWalletTx::GetAvailableCredit(bool fUseCache,
                                      const isminefilter &filter) const {
     if (pwallet == nullptr) {
         return Amount::zero();
     }
 
     // Avoid caching ismine for NO or ALL cases (could remove this check and
     // simplify in the future).
     bool allow_cache =
         (filter & ISMINE_ALL) && (filter & ISMINE_ALL) != ISMINE_ALL;
 
     // Must wait until coinbase is safely deep enough in the chain before
     // valuing it.
     if (IsImmatureCoinBase()) {
         return Amount::zero();
     }
 
     if (fUseCache && allow_cache &&
         m_amounts[AVAILABLE_CREDIT].m_cached[filter]) {
         return m_amounts[AVAILABLE_CREDIT].m_value[filter];
     }
 
     bool allow_used_addresses =
         (filter & ISMINE_USED) ||
         !pwallet->IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE);
     Amount nCredit = Amount::zero();
     const TxId &txid = GetId();
     for (uint32_t i = 0; i < tx->vout.size(); i++) {
         if (!pwallet->IsSpent(COutPoint(txid, i)) &&
             (allow_used_addresses || !pwallet->IsSpentKey(txid, i))) {
             const CTxOut &txout = tx->vout[i];
             nCredit += pwallet->GetCredit(txout, filter);
             if (!MoneyRange(nCredit)) {
                 throw std::runtime_error(std::string(__func__) +
                                          " : value out of range");
             }
         }
     }
 
     if (allow_cache) {
         m_amounts[AVAILABLE_CREDIT].Set(filter, nCredit);
         m_is_cache_empty = false;
     }
 
     return nCredit;
 }
 
 Amount CWalletTx::GetImmatureWatchOnlyCredit(const bool fUseCache) const {
     if (IsImmatureCoinBase() && IsInMainChain()) {
         return GetCachableAmount(IMMATURE_CREDIT, ISMINE_WATCH_ONLY,
                                  !fUseCache);
     }
 
     return Amount::zero();
 }
 
 Amount CWalletTx::GetChange() const {
     if (fChangeCached) {
         return nChangeCached;
     }
 
     nChangeCached = pwallet->GetChange(*tx);
     fChangeCached = true;
     return nChangeCached;
 }
 
 bool CWalletTx::InMempool() const {
     return fInMempool;
 }
 
 bool CWalletTx::IsTrusted() const {
     std::set<TxId> s;
     return IsTrusted(s);
 }
 
 bool CWalletTx::IsTrusted(std::set<TxId> &trusted_parents) const {
     // Quick answer in most cases
     TxValidationState state;
     if (!pwallet->chain().contextualCheckTransactionForCurrentBlock(*tx,
                                                                     state)) {
         return false;
     }
 
     int nDepth = GetDepthInMainChain();
     if (nDepth >= 1) {
         return true;
     }
 
     if (nDepth < 0) {
         return false;
     }
 
     // using wtx's cached debit
     if (!pwallet->m_spend_zero_conf_change || !IsFromMe(ISMINE_ALL)) {
         return false;
     }
 
     // Don't trust unconfirmed transactions from us unless they are in the
     // mempool.
     if (!InMempool()) {
         return false;
     }
 
     // Trusted if all inputs are from us and are in the mempool:
     for (const CTxIn &txin : tx->vin) {
         // Transactions not sent by us: not trusted
         const CWalletTx *parent = pwallet->GetWalletTx(txin.prevout.GetTxId());
         if (parent == nullptr) {
             return false;
         }
 
         const CTxOut &parentOut = parent->tx->vout[txin.prevout.GetN()];
         // Check that this specific input being spent is trusted
         if (pwallet->IsMine(parentOut) != ISMINE_SPENDABLE) {
             return false;
         }
         // If we've already trusted this parent, continue
         if (trusted_parents.count(parent->GetId())) {
             continue;
         }
         // Recurse to check that the parent is also trusted
         if (!parent->IsTrusted(trusted_parents)) {
             return false;
         }
         trusted_parents.insert(parent->GetId());
     }
 
     return true;
 }
 
 bool CWalletTx::IsEquivalentTo(const CWalletTx &_tx) const {
     CMutableTransaction tx1{*this->tx};
     CMutableTransaction tx2{*_tx.tx};
     for (auto &txin : tx1.vin) {
         txin.scriptSig = CScript();
     }
 
     for (auto &txin : tx2.vin) {
         txin.scriptSig = CScript();
     }
 
     return CTransaction(tx1) == CTransaction(tx2);
 }
 
 // Rebroadcast transactions from the wallet. We do this on a random timer
 // to slightly obfuscate which transactions come from our wallet.
 //
 // Ideally, we'd only resend transactions that we think should have been
 // mined in the most recent block. Any transaction that wasn't in the top
 // blockweight of transactions in the mempool shouldn't have been mined,
 // and so is probably just sitting in the mempool waiting to be confirmed.
 // Rebroadcasting does nothing to speed up confirmation and only damages
 // privacy.
 void CWallet::ResendWalletTransactions() {
     // During reindex, importing and IBD, old wallet transactions become
     // unconfirmed. Don't resend them as that would spam other nodes.
     if (!chain().isReadyToBroadcast()) {
         return;
     }
 
     // Do this infrequently and randomly to avoid giving away that these are our
     // transactions.
     if (GetTime() < nNextResend || !fBroadcastTransactions) {
         return;
     }
 
     bool fFirst = (nNextResend == 0);
     // resend 12-36 hours from now, ~1 day on average.
     nNextResend = GetTime() + (12 * 60 * 60) + GetRand(24 * 60 * 60);
     if (fFirst) {
         return;
     }
 
     int submitted_tx_count = 0;
 
     { // cs_wallet scope
         LOCK(cs_wallet);
 
         // Relay transactions
         for (std::pair<const TxId, CWalletTx> &item : mapWallet) {
             CWalletTx &wtx = item.second;
             // Attempt to rebroadcast all txes more than 5 minutes older than
             // the last block. SubmitMemoryPoolAndRelay() will not rebroadcast
             // any confirmed or conflicting txs.
             if (wtx.nTimeReceived > m_best_block_time - 5 * 60) {
                 continue;
             }
             std::string unused_err_string;
             if (wtx.SubmitMemoryPoolAndRelay(unused_err_string, true)) {
                 ++submitted_tx_count;
             }
         }
     } // cs_wallet
 
     if (submitted_tx_count > 0) {
         WalletLogPrintf("%s: resubmit %u unconfirmed transactions\n", __func__,
                         submitted_tx_count);
     }
 }
 
 /** @} */ // end of mapWallet
 
 void MaybeResendWalletTxs() {
     for (const std::shared_ptr<CWallet> &pwallet : GetWallets()) {
         pwallet->ResendWalletTransactions();
     }
 }
 
 /**
  * @defgroup Actions
  *
  * @{
  */
 CWallet::Balance CWallet::GetBalance(const int min_depth,
                                      bool avoid_reuse) const {
     Balance ret;
     isminefilter reuse_filter = avoid_reuse ? ISMINE_NO : ISMINE_USED;
     LOCK(cs_wallet);
     std::set<TxId> trusted_parents;
     for (const auto &entry : mapWallet) {
         const CWalletTx &wtx = entry.second;
         const bool is_trusted{wtx.IsTrusted(trusted_parents)};
         const int tx_depth{wtx.GetDepthInMainChain()};
         const Amount tx_credit_mine{wtx.GetAvailableCredit(
             /* fUseCache */ true, ISMINE_SPENDABLE | reuse_filter)};
         const Amount tx_credit_watchonly{wtx.GetAvailableCredit(
             /* fUseCache */ true, ISMINE_WATCH_ONLY | reuse_filter)};
         if (is_trusted && tx_depth >= min_depth) {
             ret.m_mine_trusted += tx_credit_mine;
             ret.m_watchonly_trusted += tx_credit_watchonly;
         }
         if (!is_trusted && tx_depth == 0 && wtx.InMempool()) {
             ret.m_mine_untrusted_pending += tx_credit_mine;
             ret.m_watchonly_untrusted_pending += tx_credit_watchonly;
         }
         ret.m_mine_immature += wtx.GetImmatureCredit();
         ret.m_watchonly_immature += wtx.GetImmatureWatchOnlyCredit();
     }
     return ret;
 }
 
 Amount CWallet::GetAvailableBalance(const CCoinControl *coinControl) const {
     LOCK(cs_wallet);
 
     Amount balance = Amount::zero();
     std::vector<COutput> vCoins;
     AvailableCoins(vCoins, true, coinControl);
     for (const COutput &out : vCoins) {
         if (out.fSpendable) {
             balance += out.tx->tx->vout[out.i].nValue;
         }
     }
     return balance;
 }
 
 void CWallet::AvailableCoins(std::vector<COutput> &vCoins, bool fOnlySafe,
                              const CCoinControl *coinControl,
                              const Amount nMinimumAmount,
                              const Amount nMaximumAmount,
                              const Amount nMinimumSumAmount,
                              const uint64_t nMaximumCount) const {
     AssertLockHeld(cs_wallet);
 
     vCoins.clear();
     Amount nTotal = Amount::zero();
     // Either the WALLET_FLAG_AVOID_REUSE flag is not set (in which case we
     // always allow), or we default to avoiding, and only in the case where a
     // coin control object is provided, and has the avoid address reuse flag set
     // to false, do we allow already used addresses
     bool allow_used_addresses =
         !IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE) ||
         (coinControl && !coinControl->m_avoid_address_reuse);
     const int min_depth = {coinControl ? coinControl->m_min_depth
                                        : DEFAULT_MIN_DEPTH};
     const int max_depth = {coinControl ? coinControl->m_max_depth
                                        : DEFAULT_MAX_DEPTH};
 
     std::set<TxId> trusted_parents;
     for (const auto &entry : mapWallet) {
         const TxId &wtxid = entry.first;
         const CWalletTx &wtx = entry.second;
 
         TxValidationState state;
         if (!chain().contextualCheckTransactionForCurrentBlock(*wtx.tx,
                                                                state)) {
             continue;
         }
 
         if (wtx.IsImmatureCoinBase()) {
             continue;
         }
 
         int nDepth = wtx.GetDepthInMainChain();
         if (nDepth < 0) {
             continue;
         }
 
         // We should not consider coins which aren't at least in our mempool.
         // It's possible for these to be conflicted via ancestors which we may
         // never be able to detect.
         if (nDepth == 0 && !wtx.InMempool()) {
             continue;
         }
 
         bool safeTx = wtx.IsTrusted(trusted_parents);
 
         // Bitcoin-ABC: Removed check that prevents consideration of coins from
         // transactions that are replacing other transactions. This check based
         // on wtx.mapValue.count("replaces_txid") which was not being set
         // anywhere.
 
         // Similarly, we should not consider coins from transactions that have
         // been replaced. In the example above, we would want to prevent
         // creation of a transaction A' spending an output of A, because if
         // transaction B were initially confirmed, conflicting with A and A', we
         // wouldn't want to the user to create a transaction D intending to
         // replace A', but potentially resulting in a scenario where A, A', and
         // D could all be accepted (instead of just B and D, or just A and A'
         // like the user would want).
 
         // Bitcoin-ABC: retained this check as 'replaced_by_txid' is still set
         // in the wallet code.
         if (nDepth == 0 && wtx.mapValue.count("replaced_by_txid")) {
             safeTx = false;
         }
 
         if (fOnlySafe && !safeTx) {
             continue;
         }
 
         if (nDepth < min_depth || nDepth > max_depth) {
             continue;
         }
 
         for (uint32_t i = 0; i < wtx.tx->vout.size(); i++) {
             // Only consider selected coins if add_inputs is false
             if (coinControl && !coinControl->m_add_inputs &&
                 !coinControl->IsSelected(COutPoint(entry.first, i))) {
                 continue;
             }
 
             if (wtx.tx->vout[i].nValue < nMinimumAmount ||
                 wtx.tx->vout[i].nValue > nMaximumAmount) {
                 continue;
             }
 
             const COutPoint outpoint(wtxid, i);
 
             if (coinControl && coinControl->HasSelected() &&
                 !coinControl->fAllowOtherInputs &&
                 !coinControl->IsSelected(outpoint)) {
                 continue;
             }
 
             if (IsLockedCoin(outpoint)) {
                 continue;
             }
 
             if (IsSpent(outpoint)) {
                 continue;
             }
 
             isminetype mine = IsMine(wtx.tx->vout[i]);
 
             if (mine == ISMINE_NO) {
                 continue;
             }
 
             if (!allow_used_addresses && IsSpentKey(wtxid, i)) {
                 continue;
             }
 
             std::unique_ptr<SigningProvider> provider =
                 GetSolvingProvider(wtx.tx->vout[i].scriptPubKey);
 
             bool solvable =
                 provider ? IsSolvable(*provider, wtx.tx->vout[i].scriptPubKey)
                          : false;
             bool spendable =
                 ((mine & ISMINE_SPENDABLE) != ISMINE_NO) ||
                 (((mine & ISMINE_WATCH_ONLY) != ISMINE_NO) &&
                  (coinControl && coinControl->fAllowWatchOnly && solvable));
 
             vCoins.push_back(
                 COutput(&wtx, i, nDepth, spendable, solvable, safeTx,
                         (coinControl && coinControl->fAllowWatchOnly)));
 
             // Checks the sum amount of all UTXO's.
             if (nMinimumSumAmount != MAX_MONEY) {
                 nTotal += wtx.tx->vout[i].nValue;
 
                 if (nTotal >= nMinimumSumAmount) {
                     return;
                 }
             }
 
             // Checks the maximum number of UTXO's.
             if (nMaximumCount > 0 && vCoins.size() >= nMaximumCount) {
                 return;
             }
         }
     }
 }
 
 std::map<CTxDestination, std::vector<COutput>> CWallet::ListCoins() const {
     AssertLockHeld(cs_wallet);
 
     std::map<CTxDestination, std::vector<COutput>> result;
     std::vector<COutput> availableCoins;
 
     AvailableCoins(availableCoins);
 
     for (const auto &coin : availableCoins) {
         CTxDestination address;
         if ((coin.fSpendable ||
              (IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) &&
               coin.fSolvable)) &&
             ExtractDestination(
                 FindNonChangeParentOutput(*coin.tx->tx, coin.i).scriptPubKey,
                 address)) {
             result[address].emplace_back(std::move(coin));
         }
     }
 
     std::vector<COutPoint> lockedCoins;
     ListLockedCoins(lockedCoins);
     // Include watch-only for LegacyScriptPubKeyMan wallets without private keys
     const bool include_watch_only =
         GetLegacyScriptPubKeyMan() &&
         IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
     const isminetype is_mine_filter =
         include_watch_only ? ISMINE_WATCH_ONLY : ISMINE_SPENDABLE;
     for (const auto &output : lockedCoins) {
         auto it = mapWallet.find(output.GetTxId());
         if (it != mapWallet.end()) {
             int depth = it->second.GetDepthInMainChain();
             if (depth >= 0 && output.GetN() < it->second.tx->vout.size() &&
                 IsMine(it->second.tx->vout[output.GetN()]) == is_mine_filter) {
                 CTxDestination address;
                 if (ExtractDestination(
                         FindNonChangeParentOutput(*it->second.tx, output.GetN())
                             .scriptPubKey,
                         address)) {
                     result[address].emplace_back(
                         &it->second, output.GetN(), depth, true /* spendable */,
                         true /* solvable */, false /* safe */);
                 }
             }
         }
     }
 
     return result;
 }
 
 const CTxOut &CWallet::FindNonChangeParentOutput(const CTransaction &tx,
                                                  int output) const {
     const CTransaction *ptx = &tx;
     int n = output;
     while (IsChange(ptx->vout[n]) && ptx->vin.size() > 0) {
         const COutPoint &prevout = ptx->vin[0].prevout;
         auto it = mapWallet.find(prevout.GetTxId());
         if (it == mapWallet.end() ||
             it->second.tx->vout.size() <= prevout.GetN() ||
             !IsMine(it->second.tx->vout[prevout.GetN()])) {
             break;
         }
         ptx = it->second.tx.get();
         n = prevout.GetN();
     }
     return ptx->vout[n];
 }
 
 bool CWallet::SelectCoinsMinConf(
     const Amount nTargetValue, const CoinEligibilityFilter &eligibility_filter,
     std::vector<OutputGroup> groups, std::set<CInputCoin> &setCoinsRet,
     Amount &nValueRet, const CoinSelectionParams &coin_selection_params,
     bool &bnb_used) const {
     setCoinsRet.clear();
     nValueRet = Amount::zero();
 
     std::vector<OutputGroup> utxo_pool;
     if (coin_selection_params.use_bnb) {
         // Get long term estimate
         CCoinControl temp;
         temp.m_confirm_target = 1008;
         CFeeRate long_term_feerate = GetMinimumFeeRate(*this, temp);
 
         // Calculate cost of change
         Amount cost_of_change = chain().relayDustFee().GetFee(
                                     coin_selection_params.change_spend_size) +
                                 coin_selection_params.effective_fee.GetFee(
                                     coin_selection_params.change_output_size);
 
         // Filter by the min conf specs and add to utxo_pool and calculate
         // effective value
         for (OutputGroup &group : groups) {
             if (!group.EligibleForSpending(eligibility_filter)) {
                 continue;
             }
 
             group.fee = Amount::zero();
             group.long_term_fee = Amount::zero();
             group.effective_value = Amount::zero();
             for (auto it = group.m_outputs.begin();
                  it != group.m_outputs.end();) {
                 const CInputCoin &coin = *it;
                 Amount effective_value =
                     coin.txout.nValue -
                     (coin.m_input_bytes < 0
                          ? Amount::zero()
                          : coin_selection_params.effective_fee.GetFee(
                                coin.m_input_bytes));
                 // Only include outputs that are positive effective value (i.e.
                 // not dust)
                 if (effective_value > Amount::zero()) {
                     group.fee +=
                         coin.m_input_bytes < 0
                             ? Amount::zero()
                             : coin_selection_params.effective_fee.GetFee(
                                   coin.m_input_bytes);
                     group.long_term_fee +=
                         coin.m_input_bytes < 0
                             ? Amount::zero()
                             : long_term_feerate.GetFee(coin.m_input_bytes);
                     if (coin_selection_params.m_subtract_fee_outputs) {
                         group.effective_value += coin.txout.nValue;
                     } else {
                         group.effective_value += effective_value;
                     }
                     ++it;
                 } else {
                     it = group.Discard(coin);
                 }
             }
             if (group.effective_value > Amount::zero()) {
                 utxo_pool.push_back(group);
             }
         }
         // Calculate the fees for things that aren't inputs
         Amount not_input_fees = coin_selection_params.effective_fee.GetFee(
             coin_selection_params.tx_noinputs_size);
         bnb_used = true;
         return SelectCoinsBnB(utxo_pool, nTargetValue, cost_of_change,
                               setCoinsRet, nValueRet, not_input_fees);
     } else {
         // Filter by the min conf specs and add to utxo_pool
         for (const OutputGroup &group : groups) {
             if (!group.EligibleForSpending(eligibility_filter)) {
                 continue;
             }
             utxo_pool.push_back(group);
         }
         bnb_used = false;
         return KnapsackSolver(nTargetValue, utxo_pool, setCoinsRet, nValueRet);
     }
 }
 
 bool CWallet::SelectCoins(const std::vector<COutput> &vAvailableCoins,
                           const Amount nTargetValue,
                           std::set<CInputCoin> &setCoinsRet, Amount &nValueRet,
                           const CCoinControl &coin_control,
                           CoinSelectionParams &coin_selection_params,
                           bool &bnb_used) const {
     std::vector<COutput> vCoins(vAvailableCoins);
     Amount value_to_select = nTargetValue;
 
     // Default to bnb was not used. If we use it, we set it later
     bnb_used = false;
 
     // coin control -> return all selected outputs (we want all selected to go
     // into the transaction for sure)
     if (coin_control.HasSelected() && !coin_control.fAllowOtherInputs) {
         for (const COutput &out : vCoins) {
             if (!out.fSpendable) {
                 continue;
             }
 
             nValueRet += out.tx->tx->vout[out.i].nValue;
             setCoinsRet.insert(out.GetInputCoin());
         }
 
         return (nValueRet >= nTargetValue);
     }
 
     // Calculate value from preset inputs and store them.
     std::set<CInputCoin> setPresetCoins;
     Amount nValueFromPresetInputs = Amount::zero();
 
     std::vector<COutPoint> vPresetInputs;
     coin_control.ListSelected(vPresetInputs);
 
     for (const COutPoint &outpoint : vPresetInputs) {
         std::map<TxId, CWalletTx>::const_iterator it =
             mapWallet.find(outpoint.GetTxId());
         if (it != mapWallet.end()) {
             const CWalletTx &wtx = it->second;
             // Clearly invalid input, fail
             if (wtx.tx->vout.size() <= outpoint.GetN()) {
                 return false;
             }
             // Just to calculate the marginal byte size
             CInputCoin coin(wtx.tx, outpoint.GetN(),
                             wtx.GetSpendSize(outpoint.GetN(), false));
             nValueFromPresetInputs += coin.txout.nValue;
             if (coin.m_input_bytes <= 0) {
                 // Not solvable, can't estimate size for fee
                 return false;
             }
             coin.effective_value =
                 coin.txout.nValue -
                 coin_selection_params.effective_fee.GetFee(coin.m_input_bytes);
             if (coin_selection_params.use_bnb) {
                 value_to_select -= coin.effective_value;
             } else {
                 value_to_select -= coin.txout.nValue;
             }
             setPresetCoins.insert(coin);
         } else {
             return false; // TODO: Allow non-wallet inputs
         }
     }
 
     // Remove preset inputs from vCoins
     for (std::vector<COutput>::iterator it = vCoins.begin();
          it != vCoins.end() && coin_control.HasSelected();) {
         if (setPresetCoins.count(it->GetInputCoin())) {
             it = vCoins.erase(it);
         } else {
             ++it;
         }
     }
 
     size_t max_ancestors{0};
     size_t max_descendants{0};
     chain().getPackageLimits(max_ancestors, max_descendants);
     bool fRejectLongChains = gArgs.GetBoolArg(
         "-walletrejectlongchains", DEFAULT_WALLET_REJECT_LONG_CHAINS);
 
     // form groups from remaining coins; note that preset coins will not
     // automatically have their associated (same address) coins included
     if (coin_control.m_avoid_partial_spends &&
         vCoins.size() > OUTPUT_GROUP_MAX_ENTRIES) {
         // Cases where we have 11+ outputs all pointing to the same destination
         // may result in privacy leaks as they will potentially be
         // deterministically sorted. We solve that by explicitly shuffling the
         // outputs before processing
         Shuffle(vCoins.begin(), vCoins.end(), FastRandomContext());
     }
 
     std::vector<OutputGroup> groups = GroupOutputs(
         vCoins, !coin_control.m_avoid_partial_spends, max_ancestors);
 
     bool res =
         value_to_select <= Amount::zero() ||
         SelectCoinsMinConf(value_to_select, CoinEligibilityFilter(1, 6, 0),
                            groups, setCoinsRet, nValueRet,
                            coin_selection_params, bnb_used) ||
         SelectCoinsMinConf(value_to_select, CoinEligibilityFilter(1, 1, 0),
                            groups, setCoinsRet, nValueRet,
                            coin_selection_params, bnb_used) ||
         (m_spend_zero_conf_change &&
          SelectCoinsMinConf(value_to_select, CoinEligibilityFilter(0, 1, 2),
                             groups, setCoinsRet, nValueRet,
                             coin_selection_params, bnb_used)) ||
         (m_spend_zero_conf_change &&
          SelectCoinsMinConf(
              value_to_select,
              CoinEligibilityFilter(0, 1, std::min((size_t)4, max_ancestors / 3),
                                    std::min((size_t)4, max_descendants / 3)),
              groups, setCoinsRet, nValueRet, coin_selection_params,
              bnb_used)) ||
         (m_spend_zero_conf_change &&
          SelectCoinsMinConf(value_to_select,
                             CoinEligibilityFilter(0, 1, max_ancestors / 2,
                                                   max_descendants / 2),
                             groups, setCoinsRet, nValueRet,
                             coin_selection_params, bnb_used)) ||
         (m_spend_zero_conf_change &&
          SelectCoinsMinConf(value_to_select,
                             CoinEligibilityFilter(0, 1, max_ancestors - 1,
                                                   max_descendants - 1),
                             groups, setCoinsRet, nValueRet,
                             coin_selection_params, bnb_used)) ||
         (m_spend_zero_conf_change && !fRejectLongChains &&
          SelectCoinsMinConf(
              value_to_select,
              CoinEligibilityFilter(0, 1, std::numeric_limits<uint64_t>::max()),
              groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used));
 
     // Because SelectCoinsMinConf clears the setCoinsRet, we now add the
     // possible inputs to the coinset.
     util::insert(setCoinsRet, setPresetCoins);
 
     // Add preset inputs to the total value selected.
     nValueRet += nValueFromPresetInputs;
 
     return res;
 }
 
 bool CWallet::SignTransaction(CMutableTransaction &tx) const {
     AssertLockHeld(cs_wallet);
 
     // Build coins map
     std::map<COutPoint, Coin> coins;
     for (auto &input : tx.vin) {
         auto mi = mapWallet.find(input.prevout.GetTxId());
         if (mi == mapWallet.end() ||
             input.prevout.GetN() >= mi->second.tx->vout.size()) {
             return false;
         }
         const CWalletTx &wtx = mi->second;
         coins[input.prevout] =
             Coin(wtx.tx->vout[input.prevout.GetN()], wtx.m_confirm.block_height,
                  wtx.IsCoinBase());
     }
     std::map<int, std::string> input_errors;
     return SignTransaction(tx, coins, SigHashType().withForkId(), input_errors);
 }
 
 bool CWallet::SignTransaction(CMutableTransaction &tx,
                               const std::map<COutPoint, Coin> &coins,
                               SigHashType sighash,
                               std::map<int, std::string> &input_errors) const {
     // Try to sign with all ScriptPubKeyMans
     for (ScriptPubKeyMan *spk_man : GetAllScriptPubKeyMans()) {
         // spk_man->SignTransaction will return true if the transaction is
         // complete, so we can exit early and return true if that happens
         if (spk_man->SignTransaction(tx, coins, sighash, input_errors)) {
             return true;
         }
     }
 
     // At this point, one input was not fully signed otherwise we would have
     // exited already Find that input and figure out what went wrong.
     for (size_t i = 0; i < tx.vin.size(); i++) {
         // Get the prevout
         CTxIn &txin = tx.vin[i];
         auto coin = coins.find(txin.prevout);
         if (coin == coins.end() || coin->second.IsSpent()) {
             input_errors[i] = "Input not found or already spent";
             continue;
         }
 
         // Check if this input is complete
         SignatureData sigdata =
             DataFromTransaction(tx, i, coin->second.GetTxOut());
         if (!sigdata.complete) {
             input_errors[i] = "Unable to sign input, missing keys";
             continue;
         }
     }
 
     // When there are no available providers for the remaining inputs, use the
     // legacy provider so we can get proper error messages.
     auto legacy_spk_man = GetLegacyScriptPubKeyMan();
     if (legacy_spk_man &&
         legacy_spk_man->SignTransaction(tx, coins, sighash, input_errors)) {
         return true;
     }
 
     return false;
 }
 
 TransactionError CWallet::FillPSBT(PartiallySignedTransaction &psbtx,
                                    bool &complete, SigHashType sighash_type,
                                    bool sign, bool bip32derivs) const {
     LOCK(cs_wallet);
     // Get all of the previous transactions
     for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
         const CTxIn &txin = psbtx.tx->vin[i];
         PSBTInput &input = psbtx.inputs.at(i);
 
         if (PSBTInputSigned(input)) {
             continue;
         }
 
-        // Verify input looks sane.
-        if (!input.IsSane()) {
-            return TransactionError::INVALID_PSBT;
-        }
-
         // If we have no utxo, grab it from the wallet.
         if (input.utxo.IsNull()) {
             const TxId &txid = txin.prevout.GetTxId();
             const auto it = mapWallet.find(txid);
             if (it != mapWallet.end()) {
                 const CWalletTx &wtx = it->second;
                 CTxOut utxo = wtx.tx->vout[txin.prevout.GetN()];
                 // Update UTXOs from the wallet.
                 input.utxo = utxo;
             }
         }
     }
 
     // Fill in information from ScriptPubKeyMans
     for (ScriptPubKeyMan *spk_man : GetAllScriptPubKeyMans()) {
         TransactionError res =
             spk_man->FillPSBT(psbtx, sighash_type, sign, bip32derivs);
         if (res != TransactionError::OK) {
             return res;
         }
     }
 
     // Complete if every input is now signed
     complete = true;
     for (const auto &input : psbtx.inputs) {
         complete &= PSBTInputSigned(input);
     }
 
     return TransactionError::OK;
 }
 
 SigningResult CWallet::SignMessage(const std::string &message,
                                    const PKHash &pkhash,
                                    std::string &str_sig) const {
     SignatureData sigdata;
     CScript script_pub_key = GetScriptForDestination(pkhash);
     for (const auto &spk_man_pair : m_spk_managers) {
         if (spk_man_pair.second->CanProvide(script_pub_key, sigdata)) {
             return spk_man_pair.second->SignMessage(message, pkhash, str_sig);
         }
     }
     return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
 }
 
 bool CWallet::FundTransaction(CMutableTransaction &tx, Amount &nFeeRet,
                               int &nChangePosInOut, bilingual_str &error,
                               bool lockUnspents,
                               const std::set<int> &setSubtractFeeFromOutputs,
                               CCoinControl coinControl) {
     std::vector<CRecipient> vecSend;
 
     // Turn the txout set into a CRecipient vector.
     for (size_t idx = 0; idx < tx.vout.size(); idx++) {
         const CTxOut &txOut = tx.vout[idx];
         CRecipient recipient = {txOut.scriptPubKey, txOut.nValue,
                                 setSubtractFeeFromOutputs.count(idx) == 1};
         vecSend.push_back(recipient);
     }
 
     coinControl.fAllowOtherInputs = true;
 
     for (const CTxIn &txin : tx.vin) {
         coinControl.Select(txin.prevout);
     }
 
     // Acquire the locks to prevent races to the new locked unspents between the
     // CreateTransaction call and LockCoin calls (when lockUnspents is true).
     LOCK(cs_wallet);
 
     CTransactionRef tx_new;
     if (!CreateTransaction(vecSend, tx_new, nFeeRet, nChangePosInOut, error,
                            coinControl, false)) {
         return false;
     }
 
     if (nChangePosInOut != -1) {
         tx.vout.insert(tx.vout.begin() + nChangePosInOut,
                        tx_new->vout[nChangePosInOut]);
     }
 
     // Copy output sizes from new transaction; they may have had the fee
     // subtracted from them.
     for (size_t idx = 0; idx < tx.vout.size(); idx++) {
         tx.vout[idx].nValue = tx_new->vout[idx].nValue;
     }
 
     // Add new txins (keeping original txin scriptSig/order)
     for (const CTxIn &txin : tx_new->vin) {
         if (!coinControl.IsSelected(txin.prevout)) {
             tx.vin.push_back(txin);
 
             if (lockUnspents) {
                 LockCoin(txin.prevout);
             }
         }
     }
 
     return true;
 }
 
 static bool IsCurrentForAntiFeeSniping(interfaces::Chain &chain,
                                        const BlockHash &block_hash) {
     if (chain.isInitialBlockDownload()) {
         return false;
     }
 
     // in seconds
     constexpr int64_t MAX_ANTI_FEE_SNIPING_TIP_AGE = 8 * 60 * 60;
     int64_t block_time;
     CHECK_NONFATAL(chain.findBlock(block_hash, FoundBlock().time(block_time)));
     if (block_time < (GetTime() - MAX_ANTI_FEE_SNIPING_TIP_AGE)) {
         return false;
     }
     return true;
 }
 
 /**
  * Return a height-based locktime for new transactions (uses the height of the
  * current chain tip unless we are not synced with the current chain
  */
 static uint32_t GetLocktimeForNewTransaction(interfaces::Chain &chain,
                                              const BlockHash &block_hash,
                                              int block_height) {
     uint32_t locktime;
     // Discourage fee sniping.
     //
     // For a large miner the value of the transactions in the best block and
     // the mempool can exceed the cost of deliberately attempting to mine two
     // blocks to orphan the current best block. By setting nLockTime such that
     // only the next block can include the transaction, we discourage this
     // practice as the height restricted and limited blocksize gives miners
     // considering fee sniping fewer options for pulling off this attack.
     //
     // A simple way to think about this is from the wallet's point of view we
     // always want the blockchain to move forward. By setting nLockTime this
     // way we're basically making the statement that we only want this
     // transaction to appear in the next block; we don't want to potentially
     // encourage reorgs by allowing transactions to appear at lower heights
     // than the next block in forks of the best chain.
     //
     // Of course, the subsidy is high enough, and transaction volume low
     // enough, that fee sniping isn't a problem yet, but by implementing a fix
     // now we ensure code won't be written that makes assumptions about
     // nLockTime that preclude a fix later.
     if (IsCurrentForAntiFeeSniping(chain, block_hash)) {
         locktime = block_height;
 
         // Secondly occasionally randomly pick a nLockTime even further back, so
         // that transactions that are delayed after signing for whatever reason,
         // e.g. high-latency mix networks and some CoinJoin implementations,
         // have better privacy.
         if (GetRandInt(10) == 0) {
             locktime = std::max(0, int(locktime) - GetRandInt(100));
         }
     } else {
         // If our chain is lagging behind, we can't discourage fee sniping nor
         // help the privacy of high-latency transactions. To avoid leaking a
         // potentially unique "nLockTime fingerprint", set nLockTime to a
         // constant.
         locktime = 0;
     }
     assert(locktime < LOCKTIME_THRESHOLD);
     return locktime;
 }
 
 OutputType
 CWallet::TransactionChangeType(OutputType change_type,
                                const std::vector<CRecipient> &vecSend) {
     // If -changetype is specified, always use that change type.
     if (change_type != OutputType::CHANGE_AUTO) {
         return change_type;
     }
 
     // if m_default_address_type is legacy, use legacy address as change.
     if (m_default_address_type == OutputType::LEGACY) {
         return OutputType::LEGACY;
     }
 
     // else use m_default_address_type for change
     return m_default_address_type;
 }
 
 bool CWallet::CreateTransactionInternal(const std::vector<CRecipient> &vecSend,
                                         CTransactionRef &tx, Amount &nFeeRet,
                                         int &nChangePosInOut,
                                         bilingual_str &error,
                                         const CCoinControl &coin_control,
                                         bool sign) {
     Amount nValue = Amount::zero();
     const OutputType change_type = TransactionChangeType(
         coin_control.m_change_type ? *coin_control.m_change_type
                                    : m_default_change_type,
         vecSend);
     ReserveDestination reservedest(this, change_type);
     int nChangePosRequest = nChangePosInOut;
     unsigned int nSubtractFeeFromAmount = 0;
     for (const auto &recipient : vecSend) {
         if (nValue < Amount::zero() || recipient.nAmount < Amount::zero()) {
             error = _("Transaction amounts must not be negative");
             return false;
         }
 
         nValue += recipient.nAmount;
 
         if (recipient.fSubtractFeeFromAmount) {
             nSubtractFeeFromAmount++;
         }
     }
 
     if (vecSend.empty()) {
         error = _("Transaction must have at least one recipient");
         return false;
     }
 
     CMutableTransaction txNew;
 
     {
         std::set<CInputCoin> setCoins;
         LOCK(cs_wallet);
         txNew.nLockTime = GetLocktimeForNewTransaction(
             chain(), GetLastBlockHash(), GetLastBlockHeight());
         std::vector<COutput> vAvailableCoins;
         AvailableCoins(vAvailableCoins, true, &coin_control);
         // Parameters for coin selection, init with dummy
         CoinSelectionParams coin_selection_params;
 
         // Create change script that will be used if we need change
         // TODO: pass in scriptChange instead of reservedest so
         // change transaction isn't always pay-to-bitcoin-address
         CScript scriptChange;
 
         // coin control: send change to custom address
         if (!boost::get<CNoDestination>(&coin_control.destChange)) {
             scriptChange = GetScriptForDestination(coin_control.destChange);
 
             // no coin control: send change to newly generated address
         } else {
             // Note: We use a new key here to keep it from being obvious
             // which side is the change.
             //  The drawback is that by not reusing a previous key, the
             //  change may be lost if a backup is restored, if the backup
             //  doesn't have the new private key for the change. If we
             //  reused the old key, it would be possible to add code to look
             //  for and rediscover unknown transactions that were written
             //  with keys of ours to recover post-backup change.
 
             // Reserve a new key pair from key pool. If it fails, provide a
             // dummy destination in case we don't need change.
             CTxDestination dest;
             if (!reservedest.GetReservedDestination(dest, true)) {
                 error = _("Transaction needs a change address, but we can't "
                           "generate it. Please call keypoolrefill first.");
             }
 
             scriptChange = GetScriptForDestination(dest);
             // A valid destination implies a change script (and
             // vice-versa). An empty change script will abort later, if the
             // change keypool ran out, but change is required.
             CHECK_NONFATAL(IsValidDestination(dest) != scriptChange.empty());
         }
         CTxOut change_prototype_txout(Amount::zero(), scriptChange);
         coin_selection_params.change_output_size =
             GetSerializeSize(change_prototype_txout);
 
         // Get the fee rate to use effective values in coin selection
         CFeeRate nFeeRateNeeded = GetMinimumFeeRate(*this, coin_control);
 
         nFeeRet = Amount::zero();
         bool pick_new_inputs = true;
         Amount nValueIn = Amount::zero();
 
         // BnB selector is the only selector used when this is true.
         // That should only happen on the first pass through the loop.
         coin_selection_params.use_bnb = true;
         // If we are doing subtract fee from recipient, don't use effective
         // values
         coin_selection_params.m_subtract_fee_outputs =
             nSubtractFeeFromAmount != 0;
         // Start with no fee and loop until there is enough fee
         while (true) {
             nChangePosInOut = nChangePosRequest;
             txNew.vin.clear();
             txNew.vout.clear();
             bool fFirst = true;
 
             Amount nValueToSelect = nValue;
             if (nSubtractFeeFromAmount == 0) {
                 nValueToSelect += nFeeRet;
             }
 
             // vouts to the payees
             if (!coin_selection_params.m_subtract_fee_outputs) {
                 // Static size overhead + outputs vsize. 4 nVersion, 4
                 // nLocktime, 1 input count, 1 output count
                 coin_selection_params.tx_noinputs_size = 10;
             }
             // vouts to the payees
             for (const auto &recipient : vecSend) {
                 CTxOut txout(recipient.nAmount, recipient.scriptPubKey);
 
                 if (recipient.fSubtractFeeFromAmount) {
                     assert(nSubtractFeeFromAmount != 0);
                     // Subtract fee equally from each selected recipient.
                     txout.nValue -= nFeeRet / int(nSubtractFeeFromAmount);
 
                     // First receiver pays the remainder not divisible by output
                     // count.
                     if (fFirst) {
                         fFirst = false;
                         txout.nValue -= nFeeRet % int(nSubtractFeeFromAmount);
                     }
                 }
 
                 // Include the fee cost for outputs. Note this is only used for
                 // BnB right now
                 if (!coin_selection_params.m_subtract_fee_outputs) {
                     coin_selection_params.tx_noinputs_size +=
                         ::GetSerializeSize(txout, PROTOCOL_VERSION);
                 }
 
                 if (IsDust(txout, chain().relayDustFee())) {
                     if (recipient.fSubtractFeeFromAmount &&
                         nFeeRet > Amount::zero()) {
                         if (txout.nValue < Amount::zero()) {
                             error = _("The transaction amount is too small to "
                                       "pay the fee");
                         } else {
                             error = _("The transaction amount is too small to "
                                       "send after the fee has been deducted");
                         }
                     } else {
                         error = _("Transaction amount too small");
                     }
 
                     return false;
                 }
 
                 txNew.vout.push_back(txout);
             }
 
             // Choose coins to use
             bool bnb_used = false;
             if (pick_new_inputs) {
                 nValueIn = Amount::zero();
                 setCoins.clear();
                 int change_spend_size = CalculateMaximumSignedInputSize(
                     change_prototype_txout, this);
                 // If the wallet doesn't know how to sign change output, assume
                 // p2pkh as lower-bound to allow BnB to do it's thing
                 if (change_spend_size == -1) {
                     coin_selection_params.change_spend_size =
                         DUMMY_P2PKH_INPUT_SIZE;
                 } else {
                     coin_selection_params.change_spend_size =
                         size_t(change_spend_size);
                 }
                 coin_selection_params.effective_fee = nFeeRateNeeded;
                 if (!SelectCoins(vAvailableCoins, nValueToSelect, setCoins,
                                  nValueIn, coin_control, coin_selection_params,
                                  bnb_used)) {
                     // If BnB was used, it was the first pass. No longer the
                     // first pass and continue loop with knapsack.
                     if (bnb_used) {
                         coin_selection_params.use_bnb = false;
                         continue;
                     } else {
                         error = _("Insufficient funds");
                         return false;
                     }
                 }
             } else {
                 bnb_used = false;
             }
 
             const Amount nChange = nValueIn - nValueToSelect;
             if (nChange > Amount::zero()) {
                 // Fill a vout to ourself.
                 CTxOut newTxOut(nChange, scriptChange);
 
                 // Never create dust outputs; if we would, just add the dust to
                 // the fee.
                 // The nChange when BnB is used is always going to go to fees.
                 if (IsDust(newTxOut, chain().relayDustFee()) || bnb_used) {
                     nChangePosInOut = -1;
                     nFeeRet += nChange;
                 } else {
                     if (nChangePosInOut == -1) {
                         // Insert change txn at random position:
                         nChangePosInOut = GetRandInt(txNew.vout.size() + 1);
                     } else if ((unsigned int)nChangePosInOut >
                                txNew.vout.size()) {
                         error = _("Change index out of range");
                         return false;
                     }
 
                     std::vector<CTxOut>::iterator position =
                         txNew.vout.begin() + nChangePosInOut;
                     txNew.vout.insert(position, newTxOut);
                 }
             } else {
                 nChangePosInOut = -1;
             }
 
             // Dummy fill vin for maximum size estimation
             //
             for (const auto &coin : setCoins) {
                 txNew.vin.push_back(CTxIn(coin.outpoint, CScript()));
             }
 
             CTransaction txNewConst(txNew);
             int nBytes = CalculateMaximumSignedTxSize(
                 txNewConst, this, coin_control.fAllowWatchOnly);
             if (nBytes < 0) {
                 error = _("Signing transaction failed");
                 return false;
             }
 
             Amount nFeeNeeded = GetMinimumFee(*this, nBytes, coin_control);
 
             if (nFeeRet >= nFeeNeeded) {
                 // Reduce fee to only the needed amount if possible. This
                 // prevents potential overpayment in fees if the coins selected
                 // to meet nFeeNeeded result in a transaction that requires less
                 // fee than the prior iteration.
 
                 // If we have no change and a big enough excess fee, then try to
                 // construct transaction again only without picking new inputs.
                 // We now know we only need the smaller fee (because of reduced
                 // tx size) and so we should add a change output. Only try this
                 // once.
                 if (nChangePosInOut == -1 && nSubtractFeeFromAmount == 0 &&
                     pick_new_inputs) {
                     // Add 2 as a buffer in case increasing # of outputs changes
                     // compact size
                     unsigned int tx_size_with_change =
                         nBytes + coin_selection_params.change_output_size + 2;
                     Amount fee_needed_with_change =
                         GetMinimumFee(*this, tx_size_with_change, coin_control);
                     Amount minimum_value_for_change = GetDustThreshold(
                         change_prototype_txout, chain().relayDustFee());
                     if (nFeeRet >=
                         fee_needed_with_change + minimum_value_for_change) {
                         pick_new_inputs = false;
                         nFeeRet = fee_needed_with_change;
                         continue;
                     }
                 }
 
                 // If we have change output already, just increase it
                 if (nFeeRet > nFeeNeeded && nChangePosInOut != -1 &&
                     nSubtractFeeFromAmount == 0) {
                     Amount extraFeePaid = nFeeRet - nFeeNeeded;
                     std::vector<CTxOut>::iterator change_position =
                         txNew.vout.begin() + nChangePosInOut;
                     change_position->nValue += extraFeePaid;
                     nFeeRet -= extraFeePaid;
                 }
 
                 // Done, enough fee included.
                 break;
             } else if (!pick_new_inputs) {
                 // This shouldn't happen, we should have had enough excess fee
                 // to pay for the new output and still meet nFeeNeeded.
                 // Or we should have just subtracted fee from recipients and
                 // nFeeNeeded should not have changed.
                 error = _("Transaction fee and change calculation failed");
                 return false;
             }
 
             // Try to reduce change to include necessary fee.
             if (nChangePosInOut != -1 && nSubtractFeeFromAmount == 0) {
                 Amount additionalFeeNeeded = nFeeNeeded - nFeeRet;
                 std::vector<CTxOut>::iterator change_position =
                     txNew.vout.begin() + nChangePosInOut;
                 // Only reduce change if remaining amount is still a large
                 // enough output.
                 if (change_position->nValue >=
                     MIN_FINAL_CHANGE + additionalFeeNeeded) {
                     change_position->nValue -= additionalFeeNeeded;
                     nFeeRet += additionalFeeNeeded;
                     // Done, able to increase fee from change.
                     break;
                 }
             }
 
             // If subtracting fee from recipients, we now know what fee we
             // need to subtract, we have no reason to reselect inputs.
             if (nSubtractFeeFromAmount > 0) {
                 pick_new_inputs = false;
             }
 
             // Include more fee and try again.
             nFeeRet = nFeeNeeded;
             coin_selection_params.use_bnb = false;
             continue;
         }
 
         // Give up if change keypool ran out and change is required
         if (scriptChange.empty() && nChangePosInOut != -1) {
             return false;
         }
 
         // Shuffle selected coins and fill in final vin
         txNew.vin.clear();
         std::vector<CInputCoin> selected_coins(setCoins.begin(),
                                                setCoins.end());
         Shuffle(selected_coins.begin(), selected_coins.end(),
                 FastRandomContext());
 
         // Note how the sequence number is set to non-maxint so that
         // the nLockTime set above actually works.
         for (const auto &coin : selected_coins) {
             txNew.vin.push_back(
                 CTxIn(coin.outpoint, CScript(),
                       std::numeric_limits<uint32_t>::max() - 1));
         }
 
         if (sign && !SignTransaction(txNew)) {
             error = _("Signing transaction failed");
             return false;
         }
 
         // Return the constructed transaction data.
         tx = MakeTransactionRef(std::move(txNew));
 
         // Limit size.
         if (tx->GetTotalSize() > MAX_STANDARD_TX_SIZE) {
             error = _("Transaction too large");
             return false;
         }
     }
 
     if (nFeeRet > m_default_max_tx_fee) {
         error = TransactionErrorString(TransactionError::MAX_FEE_EXCEEDED);
         return false;
     }
 
     if (gArgs.GetBoolArg("-walletrejectlongchains",
                          DEFAULT_WALLET_REJECT_LONG_CHAINS)) {
         // Lastly, ensure this tx will pass the mempool's chain limits
         if (!chain().checkChainLimits(tx)) {
             error = _("Transaction has too long of a mempool chain");
             return false;
         }
     }
 
     // Before we return success, we assume any change key will be used to
     // prevent accidental re-use.
     reservedest.KeepDestination();
 
     return true;
 }
 
 bool CWallet::CreateTransaction(const std::vector<CRecipient> &vecSend,
                                 CTransactionRef &tx, Amount &nFeeRet,
                                 int &nChangePosInOut, bilingual_str &error,
                                 const CCoinControl &coin_control, bool sign) {
     int nChangePosIn = nChangePosInOut;
     CTransactionRef tx2 = tx;
     bool res = CreateTransactionInternal(vecSend, tx, nFeeRet, nChangePosInOut,
                                          error, coin_control, sign);
     // try with avoidpartialspends unless it's enabled already
     if (res &&
         nFeeRet >
             Amount::zero() /* 0 means non-functional fee rate estimation */
         && m_max_aps_fee > (-1 * SATOSHI) &&
         !coin_control.m_avoid_partial_spends) {
         CCoinControl tmp_cc = coin_control;
         tmp_cc.m_avoid_partial_spends = true;
         Amount nFeeRet2;
         int nChangePosInOut2 = nChangePosIn;
         // fired and forgotten; if an error occurs, we discard the results
         bilingual_str error2;
         if (CreateTransactionInternal(vecSend, tx2, nFeeRet2, nChangePosInOut2,
                                       error2, tmp_cc, sign)) {
             // if fee of this alternative one is within the range of the max
             // fee, we use this one
             const bool use_aps = nFeeRet2 <= nFeeRet + m_max_aps_fee;
             WalletLogPrintf(
                 "Fee non-grouped = %lld, grouped = %lld, using %s\n", nFeeRet,
                 nFeeRet2, use_aps ? "grouped" : "non-grouped");
             if (use_aps) {
                 tx = tx2;
                 nFeeRet = nFeeRet2;
                 nChangePosInOut = nChangePosInOut2;
             }
         }
     }
     return res;
 }
 
 void CWallet::CommitTransaction(
     CTransactionRef tx, mapValue_t mapValue,
     std::vector<std::pair<std::string, std::string>> orderForm) {
     LOCK(cs_wallet);
 
     WalletLogPrintfToBeContinued("CommitTransaction:\n%s", tx->ToString());
 
     // Add tx to wallet, because if it has change it's also ours, otherwise just
     // for transaction history.
     AddToWallet(tx, {}, [&](CWalletTx &wtx, bool new_tx) {
         CHECK_NONFATAL(wtx.mapValue.empty());
         CHECK_NONFATAL(wtx.vOrderForm.empty());
         wtx.mapValue = std::move(mapValue);
         wtx.vOrderForm = std::move(orderForm);
         wtx.fTimeReceivedIsTxTime = true;
         wtx.fFromMe = true;
         return true;
     });
 
     // Notify that old coins are spent.
     for (const CTxIn &txin : tx->vin) {
         CWalletTx &coin = mapWallet.at(txin.prevout.GetTxId());
         coin.MarkDirty();
         NotifyTransactionChanged(this, coin.GetId(), CT_UPDATED);
     }
 
     // Get the inserted-CWalletTx from mapWallet so that the
     // fInMempool flag is cached properly
     CWalletTx &wtx = mapWallet.at(tx->GetId());
 
     if (!fBroadcastTransactions) {
         // Don't submit tx to the mempool
         return;
     }
 
     std::string err_string;
     if (!wtx.SubmitMemoryPoolAndRelay(err_string, true)) {
         WalletLogPrintf("CommitTransaction(): Transaction cannot be broadcast "
                         "immediately, %s\n",
                         err_string);
         // TODO: if we expect the failure to be long term or permanent, instead
         // delete wtx from the wallet and return failure.
     }
 }
 
 DBErrors CWallet::LoadWallet(bool &fFirstRunRet) {
     LOCK(cs_wallet);
 
     fFirstRunRet = false;
     DBErrors nLoadWalletRet = WalletBatch(*database, "cr+").LoadWallet(this);
     if (nLoadWalletRet == DBErrors::NEED_REWRITE) {
         if (database->Rewrite("\x04pool")) {
             for (const auto &spk_man_pair : m_spk_managers) {
                 spk_man_pair.second->RewriteDB();
             }
         }
     }
 
     // This wallet is in its first run if there are no ScriptPubKeyMans and it
     // isn't blank or no privkeys
     fFirstRunRet = m_spk_managers.empty() &&
                    !IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) &&
                    !IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET);
     if (fFirstRunRet) {
         assert(m_external_spk_managers.empty());
         assert(m_internal_spk_managers.empty());
     }
 
     if (nLoadWalletRet != DBErrors::LOAD_OK) {
         return nLoadWalletRet;
     }
 
     return DBErrors::LOAD_OK;
 }
 
 DBErrors CWallet::ZapSelectTx(std::vector<TxId> &txIdsIn,
                               std::vector<TxId> &txIdsOut) {
     AssertLockHeld(cs_wallet);
     DBErrors nZapSelectTxRet =
         WalletBatch(*database, "cr+").ZapSelectTx(txIdsIn, txIdsOut);
     for (const TxId &txid : txIdsOut) {
         const auto &it = mapWallet.find(txid);
         wtxOrdered.erase(it->second.m_it_wtxOrdered);
         mapWallet.erase(it);
         NotifyTransactionChanged(this, txid, CT_DELETED);
     }
 
     if (nZapSelectTxRet == DBErrors::NEED_REWRITE) {
         if (database->Rewrite("\x04pool")) {
             for (const auto &spk_man_pair : m_spk_managers) {
                 spk_man_pair.second->RewriteDB();
             }
         }
     }
 
     if (nZapSelectTxRet != DBErrors::LOAD_OK) {
         return nZapSelectTxRet;
     }
 
     MarkDirty();
 
     return DBErrors::LOAD_OK;
 }
 
 DBErrors CWallet::ZapWalletTx(std::list<CWalletTx> &vWtx) {
     DBErrors nZapWalletTxRet = WalletBatch(*database, "cr+").ZapWalletTx(vWtx);
     if (nZapWalletTxRet == DBErrors::NEED_REWRITE) {
         if (database->Rewrite("\x04pool")) {
             for (const auto &spk_man_pair : m_spk_managers) {
                 spk_man_pair.second->RewriteDB();
             }
         }
     }
 
     if (nZapWalletTxRet != DBErrors::LOAD_OK) {
         return nZapWalletTxRet;
     }
 
     return DBErrors::LOAD_OK;
 }
 
 bool CWallet::SetAddressBookWithDB(WalletBatch &batch,
                                    const CTxDestination &address,
                                    const std::string &strName,
                                    const std::string &strPurpose) {
     bool fUpdated = false;
     {
         LOCK(cs_wallet);
         std::map<CTxDestination, CAddressBookData>::iterator mi =
             m_address_book.find(address);
         fUpdated = (mi != m_address_book.end() && !mi->second.IsChange());
         m_address_book[address].SetLabel(strName);
         // Update purpose only if requested.
         if (!strPurpose.empty()) {
             m_address_book[address].purpose = strPurpose;
         }
     }
 
     NotifyAddressBookChanged(this, address, strName,
                              IsMine(address) != ISMINE_NO, strPurpose,
                              (fUpdated ? CT_UPDATED : CT_NEW));
     if (!strPurpose.empty() && !batch.WritePurpose(address, strPurpose)) {
         return false;
     }
     return batch.WriteName(address, strName);
 }
 
 bool CWallet::SetAddressBook(const CTxDestination &address,
                              const std::string &strName,
                              const std::string &strPurpose) {
     WalletBatch batch(*database);
     return SetAddressBookWithDB(batch, address, strName, strPurpose);
 }
 
 bool CWallet::DelAddressBook(const CTxDestination &address) {
     // If we want to delete receiving addresses, we need to take care that
     // DestData "used" (and possibly newer DestData) gets preserved (and the
     // "deleted" address transformed into a change entry instead of actually
     // being deleted)
     // NOTE: This isn't a problem for sending addresses because they never have
     // any DestData yet! When adding new DestData, it should be considered here
     // whether to retain or delete it (or move it?).
     if (IsMine(address)) {
         WalletLogPrintf("%s called with IsMine address, NOT SUPPORTED. Please "
                         "report this bug! %s\n",
                         __func__, PACKAGE_BUGREPORT);
         return false;
     }
 
     {
         LOCK(cs_wallet);
 
         // Delete destdata tuples associated with address
         for (const std::pair<const std::string, std::string> &item :
              m_address_book[address].destdata) {
             WalletBatch(*database).EraseDestData(address, item.first);
         }
         m_address_book.erase(address);
     }
 
     NotifyAddressBookChanged(this, address, "", IsMine(address) != ISMINE_NO,
                              "", CT_DELETED);
 
     WalletBatch(*database).ErasePurpose(address);
     return WalletBatch(*database).EraseName(address);
 }
 
 size_t CWallet::KeypoolCountExternalKeys() const {
     AssertLockHeld(cs_wallet);
 
     unsigned int count = 0;
     for (auto spk_man : GetActiveScriptPubKeyMans()) {
         count += spk_man->KeypoolCountExternalKeys();
     }
 
     return count;
 }
 
 unsigned int CWallet::GetKeyPoolSize() const {
     AssertLockHeld(cs_wallet);
 
     unsigned int count = 0;
     for (auto spk_man : GetActiveScriptPubKeyMans()) {
         count += spk_man->GetKeyPoolSize();
     }
     return count;
 }
 
 bool CWallet::TopUpKeyPool(unsigned int kpSize) {
     LOCK(cs_wallet);
     bool res = true;
     for (auto spk_man : GetActiveScriptPubKeyMans()) {
         res &= spk_man->TopUp(kpSize);
     }
     return res;
 }
 
 bool CWallet::GetNewDestination(const OutputType type, const std::string label,
                                 CTxDestination &dest, std::string &error) {
     LOCK(cs_wallet);
     error.clear();
     bool result = false;
     auto spk_man = GetScriptPubKeyMan(type, false /* internal */);
     if (spk_man) {
         spk_man->TopUp();
         result = spk_man->GetNewDestination(type, dest, error);
     } else {
         error = strprintf("Error: No %s addresses available.",
                           FormatOutputType(type));
     }
     if (result) {
         SetAddressBook(dest, label, "receive");
     }
 
     return result;
 }
 
 bool CWallet::GetNewChangeDestination(const OutputType type,
                                       CTxDestination &dest,
                                       std::string &error) {
     LOCK(cs_wallet);
     error.clear();
 
     ReserveDestination reservedest(this, type);
     if (!reservedest.GetReservedDestination(dest, true)) {
         error = _("Error: Keypool ran out, please call keypoolrefill first")
                     .translated;
         return false;
     }
 
     reservedest.KeepDestination();
     return true;
 }
 
 int64_t CWallet::GetOldestKeyPoolTime() const {
     LOCK(cs_wallet);
     int64_t oldestKey = std::numeric_limits<int64_t>::max();
     for (const auto &spk_man_pair : m_spk_managers) {
         oldestKey =
             std::min(oldestKey, spk_man_pair.second->GetOldestKeyPoolTime());
     }
     return oldestKey;
 }
 
 void CWallet::MarkDestinationsDirty(
     const std::set<CTxDestination> &destinations) {
     for (auto &entry : mapWallet) {
         CWalletTx &wtx = entry.second;
         if (wtx.m_is_cache_empty) {
             continue;
         }
 
         for (size_t i = 0; i < wtx.tx->vout.size(); i++) {
             CTxDestination dst;
 
             if (ExtractDestination(wtx.tx->vout[i].scriptPubKey, dst) &&
                 destinations.count(dst)) {
                 wtx.MarkDirty();
                 break;
             }
         }
     }
 }
 
 std::map<CTxDestination, Amount> CWallet::GetAddressBalances() const {
     std::map<CTxDestination, Amount> balances;
 
     LOCK(cs_wallet);
     std::set<TxId> trusted_parents;
     for (const auto &walletEntry : mapWallet) {
         const CWalletTx &wtx = walletEntry.second;
 
         if (!wtx.IsTrusted(trusted_parents)) {
             continue;
         }
 
         if (wtx.IsImmatureCoinBase()) {
             continue;
         }
 
         int nDepth = wtx.GetDepthInMainChain();
         if (nDepth < (wtx.IsFromMe(ISMINE_ALL) ? 0 : 1)) {
             continue;
         }
 
         for (uint32_t i = 0; i < wtx.tx->vout.size(); i++) {
             CTxDestination addr;
             if (!IsMine(wtx.tx->vout[i])) {
                 continue;
             }
 
             if (!ExtractDestination(wtx.tx->vout[i].scriptPubKey, addr)) {
                 continue;
             }
 
             Amount n = IsSpent(COutPoint(walletEntry.first, i))
                            ? Amount::zero()
                            : wtx.tx->vout[i].nValue;
 
             if (!balances.count(addr)) {
                 balances[addr] = Amount::zero();
             }
             balances[addr] += n;
         }
     }
 
     return balances;
 }
 
 std::set<std::set<CTxDestination>> CWallet::GetAddressGroupings() const {
     AssertLockHeld(cs_wallet);
     std::set<std::set<CTxDestination>> groupings;
     std::set<CTxDestination> grouping;
 
     for (const auto &walletEntry : mapWallet) {
         const CWalletTx &wtx = walletEntry.second;
 
         if (wtx.tx->vin.size() > 0) {
             bool any_mine = false;
             // Group all input addresses with each other.
             for (const auto &txin : wtx.tx->vin) {
                 CTxDestination address;
                 // If this input isn't mine, ignore it.
                 if (!IsMine(txin)) {
                     continue;
                 }
 
                 if (!ExtractDestination(mapWallet.at(txin.prevout.GetTxId())
                                             .tx->vout[txin.prevout.GetN()]
                                             .scriptPubKey,
                                         address)) {
                     continue;
                 }
 
                 grouping.insert(address);
                 any_mine = true;
             }
 
             // Group change with input addresses.
             if (any_mine) {
                 for (const auto &txout : wtx.tx->vout) {
                     if (IsChange(txout)) {
                         CTxDestination txoutAddr;
                         if (!ExtractDestination(txout.scriptPubKey,
                                                 txoutAddr)) {
                             continue;
                         }
 
                         grouping.insert(txoutAddr);
                     }
                 }
             }
 
             if (grouping.size() > 0) {
                 groupings.insert(grouping);
                 grouping.clear();
             }
         }
 
         // Group lone addrs by themselves.
         for (const auto &txout : wtx.tx->vout) {
             if (IsMine(txout)) {
                 CTxDestination address;
                 if (!ExtractDestination(txout.scriptPubKey, address)) {
                     continue;
                 }
 
                 grouping.insert(address);
                 groupings.insert(grouping);
                 grouping.clear();
             }
         }
     }
 
     // A set of pointers to groups of addresses.
     std::set<std::set<CTxDestination> *> uniqueGroupings;
     // Map addresses to the unique group containing it.
     std::map<CTxDestination, std::set<CTxDestination> *> setmap;
     for (std::set<CTxDestination> _grouping : groupings) {
         // Make a set of all the groups hit by this new group.
         std::set<std::set<CTxDestination> *> hits;
         std::map<CTxDestination, std::set<CTxDestination> *>::iterator it;
         for (const CTxDestination &address : _grouping) {
             if ((it = setmap.find(address)) != setmap.end()) {
                 hits.insert((*it).second);
             }
         }
 
         // Merge all hit groups into a new single group and delete old groups.
         std::set<CTxDestination> *merged =
             new std::set<CTxDestination>(_grouping);
         for (std::set<CTxDestination> *hit : hits) {
             merged->insert(hit->begin(), hit->end());
             uniqueGroupings.erase(hit);
             delete hit;
         }
         uniqueGroupings.insert(merged);
 
         // Update setmap.
         for (const CTxDestination &element : *merged) {
             setmap[element] = merged;
         }
     }
 
     std::set<std::set<CTxDestination>> ret;
     for (const std::set<CTxDestination> *uniqueGrouping : uniqueGroupings) {
         ret.insert(*uniqueGrouping);
         delete uniqueGrouping;
     }
 
     return ret;
 }
 
 std::set<CTxDestination>
 CWallet::GetLabelAddresses(const std::string &label) const {
     LOCK(cs_wallet);
     std::set<CTxDestination> result;
     for (const std::pair<const CTxDestination, CAddressBookData> &item :
          m_address_book) {
         if (item.second.IsChange()) {
             continue;
         }
         const CTxDestination &address = item.first;
         const std::string &strName = item.second.GetLabel();
         if (strName == label) {
             result.insert(address);
         }
     }
 
     return result;
 }
 
 bool ReserveDestination::GetReservedDestination(CTxDestination &dest,
                                                 bool internal) {
     m_spk_man = pwallet->GetScriptPubKeyMan(type, internal);
     if (!m_spk_man) {
         return false;
     }
 
     if (nIndex == -1) {
         m_spk_man->TopUp();
 
         CKeyPool keypool;
         if (!m_spk_man->GetReservedDestination(type, internal, address, nIndex,
                                                keypool)) {
             return false;
         }
         fInternal = keypool.fInternal;
     }
     dest = address;
     return true;
 }
 
 void ReserveDestination::KeepDestination() {
     if (nIndex != -1) {
         m_spk_man->KeepDestination(nIndex, type);
     }
 
     nIndex = -1;
     address = CNoDestination();
 }
 
 void ReserveDestination::ReturnDestination() {
     if (nIndex != -1) {
         m_spk_man->ReturnDestination(nIndex, fInternal, address);
     }
     nIndex = -1;
     address = CNoDestination();
 }
 
 void CWallet::LockCoin(const COutPoint &output) {
     AssertLockHeld(cs_wallet);
     setLockedCoins.insert(output);
 }
 
 void CWallet::UnlockCoin(const COutPoint &output) {
     AssertLockHeld(cs_wallet);
     setLockedCoins.erase(output);
 }
 
 void CWallet::UnlockAllCoins() {
     AssertLockHeld(cs_wallet);
     setLockedCoins.clear();
 }
 
 bool CWallet::IsLockedCoin(const COutPoint &outpoint) const {
     AssertLockHeld(cs_wallet);
 
     return setLockedCoins.count(outpoint) > 0;
 }
 
 void CWallet::ListLockedCoins(std::vector<COutPoint> &vOutpts) const {
     AssertLockHeld(cs_wallet);
     for (COutPoint outpoint : setLockedCoins) {
         vOutpts.push_back(outpoint);
     }
 }
 
 /** @} */ // end of Actions
 
 void CWallet::GetKeyBirthTimes(std::map<CKeyID, int64_t> &mapKeyBirth) const {
     AssertLockHeld(cs_wallet);
     mapKeyBirth.clear();
 
     LegacyScriptPubKeyMan *spk_man = GetLegacyScriptPubKeyMan();
     assert(spk_man != nullptr);
     LOCK(spk_man->cs_KeyStore);
 
     // Get birth times for keys with metadata.
     for (const auto &entry : spk_man->mapKeyMetadata) {
         if (entry.second.nCreateTime) {
             mapKeyBirth[entry.first] = entry.second.nCreateTime;
         }
     }
 
     // map in which we'll infer heights of other keys
     std::map<CKeyID, const CWalletTx::Confirmation *> mapKeyFirstBlock;
     CWalletTx::Confirmation max_confirm;
     // the tip can be reorganized; use a 144-block safety margin
     max_confirm.block_height =
         GetLastBlockHeight() > 144 ? GetLastBlockHeight() - 144 : 0;
     CHECK_NONFATAL(chain().findAncestorByHeight(
         GetLastBlockHash(), max_confirm.block_height,
         FoundBlock().hash(max_confirm.hashBlock)));
     for (const CKeyID &keyid : spk_man->GetKeys()) {
         if (mapKeyBirth.count(keyid) == 0) {
             mapKeyFirstBlock[keyid] = &max_confirm;
         }
     }
 
     // If there are no such keys, we're done.
     if (mapKeyFirstBlock.empty()) {
         return;
     }
 
     // Find first block that affects those keys, if there are any left.
     for (const auto &entry : mapWallet) {
         // iterate over all wallet transactions...
         const CWalletTx &wtx = entry.second;
         if (wtx.m_confirm.status == CWalletTx::CONFIRMED) {
             // ... which are already in a block
             for (const CTxOut &txout : wtx.tx->vout) {
                 // Iterate over all their outputs...
                 for (const auto &keyid :
                      GetAffectedKeys(txout.scriptPubKey, *spk_man)) {
                     // ... and all their affected keys.
                     auto rit = mapKeyFirstBlock.find(keyid);
                     if (rit != mapKeyFirstBlock.end() &&
                         wtx.m_confirm.block_height <
                             rit->second->block_height) {
                         rit->second = &wtx.m_confirm;
                     }
                 }
             }
         }
     }
 
     // Extract block timestamps for those keys.
     for (const auto &entry : mapKeyFirstBlock) {
         int64_t block_time;
         CHECK_NONFATAL(chain().findBlock(entry.second->hashBlock,
                                          FoundBlock().time(block_time)));
         // block times can be 2h off
         mapKeyBirth[entry.first] = block_time - TIMESTAMP_WINDOW;
     }
 }
 
 /**
  * Compute smart timestamp for a transaction being added to the wallet.
  *
  * Logic:
  * - If sending a transaction, assign its timestamp to the current time.
  * - If receiving a transaction outside a block, assign its timestamp to the
  *   current time.
  * - If receiving a block with a future timestamp, assign all its (not already
  *   known) transactions' timestamps to the current time.
  * - If receiving a block with a past timestamp, before the most recent known
  *   transaction (that we care about), assign all its (not already known)
  *   transactions' timestamps to the same timestamp as that most-recent-known
  *   transaction.
  * - If receiving a block with a past timestamp, but after the most recent known
  *   transaction, assign all its (not already known) transactions' timestamps to
  *   the block time.
  *
  * For more information see CWalletTx::nTimeSmart,
  * https://bitcointalk.org/?topic=54527, or
  * https://github.com/bitcoin/bitcoin/pull/1393.
  */
 unsigned int CWallet::ComputeTimeSmart(const CWalletTx &wtx) const {
     unsigned int nTimeSmart = wtx.nTimeReceived;
     if (!wtx.isUnconfirmed() && !wtx.isAbandoned()) {
         int64_t blocktime;
         if (chain().findBlock(wtx.m_confirm.hashBlock,
                               FoundBlock().time(blocktime))) {
             int64_t latestNow = wtx.nTimeReceived;
             int64_t latestEntry = 0;
 
             // Tolerate times up to the last timestamp in the wallet not more
             // than 5 minutes into the future
             int64_t latestTolerated = latestNow + 300;
             const TxItems &txOrdered = wtxOrdered;
             for (auto it = txOrdered.rbegin(); it != txOrdered.rend(); ++it) {
                 CWalletTx *const pwtx = it->second;
                 if (pwtx == &wtx) {
                     continue;
                 }
                 int64_t nSmartTime;
                 nSmartTime = pwtx->nTimeSmart;
                 if (!nSmartTime) {
                     nSmartTime = pwtx->nTimeReceived;
                 }
                 if (nSmartTime <= latestTolerated) {
                     latestEntry = nSmartTime;
                     if (nSmartTime > latestNow) {
                         latestNow = nSmartTime;
                     }
                     break;
                 }
             }
 
             nTimeSmart = std::max(latestEntry, std::min(blocktime, latestNow));
         } else {
             WalletLogPrintf("%s: found %s in block %s not in index\n", __func__,
                             wtx.GetId().ToString(),
                             wtx.m_confirm.hashBlock.ToString());
         }
     }
     return nTimeSmart;
 }
 
 bool CWallet::AddDestData(WalletBatch &batch, const CTxDestination &dest,
                           const std::string &key, const std::string &value) {
     if (boost::get<CNoDestination>(&dest)) {
         return false;
     }
 
     m_address_book[dest].destdata.insert(std::make_pair(key, value));
     return batch.WriteDestData(dest, key, value);
 }
 
 bool CWallet::EraseDestData(WalletBatch &batch, const CTxDestination &dest,
                             const std::string &key) {
     if (!m_address_book[dest].destdata.erase(key)) {
         return false;
     }
 
     return batch.EraseDestData(dest, key);
 }
 
 void CWallet::LoadDestData(const CTxDestination &dest, const std::string &key,
                            const std::string &value) {
     m_address_book[dest].destdata.insert(std::make_pair(key, value));
 }
 
 bool CWallet::GetDestData(const CTxDestination &dest, const std::string &key,
                           std::string *value) const {
     std::map<CTxDestination, CAddressBookData>::const_iterator i =
         m_address_book.find(dest);
     if (i != m_address_book.end()) {
         CAddressBookData::StringMap::const_iterator j =
             i->second.destdata.find(key);
         if (j != i->second.destdata.end()) {
             if (value) {
                 *value = j->second;
             }
 
             return true;
         }
     }
     return false;
 }
 
 std::vector<std::string>
 CWallet::GetDestValues(const std::string &prefix) const {
     std::vector<std::string> values;
     for (const auto &address : m_address_book) {
         for (const auto &data : address.second.destdata) {
             if (!data.first.compare(0, prefix.size(), prefix)) {
                 values.emplace_back(data.second);
             }
         }
     }
     return values;
 }
 
 bool CWallet::Verify(const CChainParams &chainParams, interfaces::Chain &chain,
                      const WalletLocation &location,
                      bilingual_str &error_string,
                      std::vector<bilingual_str> &warnings) {
     // Do some checking on wallet path. It should be either a:
     //
     // 1. Path where a directory can be created.
     // 2. Path to an existing directory.
     // 3. Path to a symlink to a directory.
     // 4. For backwards compatibility, the name of a data file in -walletdir.
     LOCK(cs_wallets);
     const fs::path &wallet_path = location.GetPath();
     fs::file_type path_type = fs::symlink_status(wallet_path).type();
     if (!(path_type == fs::file_not_found || path_type == fs::directory_file ||
           (path_type == fs::symlink_file && fs::is_directory(wallet_path)) ||
           (path_type == fs::regular_file &&
            fs::path(location.GetName()).filename() == location.GetName()))) {
         error_string = Untranslated(
             strprintf("Invalid -wallet path '%s'. -wallet path should point to "
                       "a directory where wallet.dat and "
                       "database/log.?????????? files can be stored, a location "
                       "where such a directory could be created, "
                       "or (for backwards compatibility) the name of an "
                       "existing data file in -walletdir (%s)",
                       location.GetName(), GetWalletDir()));
         return false;
     }
 
     // Make sure that the wallet path doesn't clash with an existing wallet path
     if (IsWalletLoaded(wallet_path)) {
         error_string = Untranslated(strprintf(
             "Error loading wallet %s. Duplicate -wallet filename specified.",
             location.GetName()));
         return false;
     }
 
     // Keep same database environment instance across Verify/Recover calls
     // below.
     std::unique_ptr<WalletDatabase> database =
         WalletDatabase::Create(wallet_path);
 
     try {
         return database->Verify(error_string);
     } catch (const fs::filesystem_error &e) {
         error_string = Untranslated(
             strprintf("Error loading wallet %s. %s", location.GetName(),
                       fsbridge::get_filesystem_error_message(e)));
         return false;
     }
 }
 
 std::shared_ptr<CWallet> CWallet::CreateWalletFromFile(
     const CChainParams &chainParams, interfaces::Chain &chain,
     const WalletLocation &location, bilingual_str &error,
     std::vector<bilingual_str> &warnings, uint64_t wallet_creation_flags) {
     const std::string walletFile =
         WalletDataFilePath(location.GetPath()).string();
 
     // Needed to restore wallet transaction meta data after -zapwallettxes
     std::list<CWalletTx> vWtx;
 
     if (gArgs.GetBoolArg("-zapwallettxes", false)) {
         chain.initMessage(
             _("Zapping all transactions from wallet...").translated);
 
         std::unique_ptr<CWallet> tempWallet = std::make_unique<CWallet>(
             &chain, location, WalletDatabase::Create(location.GetPath()));
         DBErrors nZapWalletRet = tempWallet->ZapWalletTx(vWtx);
         if (nZapWalletRet != DBErrors::LOAD_OK) {
             error =
                 strprintf(_("Error loading %s: Wallet corrupted"), walletFile);
             return nullptr;
         }
     }
 
     chain.initMessage(_("Loading wallet...").translated);
 
     int64_t nStart = GetTimeMillis();
     bool fFirstRun = true;
     // TODO: Can't use std::make_shared because we need a custom deleter but
     // should be possible to use std::allocate_shared.
     std::shared_ptr<CWallet> walletInstance(
         new CWallet(&chain, location,
                     WalletDatabase::Create(location.GetPath())),
         ReleaseWallet);
     DBErrors nLoadWalletRet = walletInstance->LoadWallet(fFirstRun);
     if (nLoadWalletRet != DBErrors::LOAD_OK) {
         if (nLoadWalletRet == DBErrors::CORRUPT) {
             error =
                 strprintf(_("Error loading %s: Wallet corrupted"), walletFile);
             return nullptr;
         }
 
         if (nLoadWalletRet == DBErrors::NONCRITICAL_ERROR) {
             warnings.push_back(
                 strprintf(_("Error reading %s! All keys read correctly, but "
                             "transaction data or address book entries might be "
                             "missing or incorrect."),
                           walletFile));
         } else if (nLoadWalletRet == DBErrors::TOO_NEW) {
             error = strprintf(
                 _("Error loading %s: Wallet requires newer version of %s"),
                 walletFile, PACKAGE_NAME);
             return nullptr;
         } else if (nLoadWalletRet == DBErrors::NEED_REWRITE) {
             error = strprintf(
                 _("Wallet needed to be rewritten: restart %s to complete"),
                 PACKAGE_NAME);
             return nullptr;
         } else {
             error = strprintf(_("Error loading %s"), walletFile);
             return nullptr;
         }
     }
 
     if (fFirstRun) {
         // Ensure this wallet.dat can only be opened by clients supporting
         // HD with chain split and expects no default key.
         walletInstance->SetMinVersion(FEATURE_LATEST);
 
         walletInstance->SetWalletFlags(wallet_creation_flags, false);
 
         // Only create LegacyScriptPubKeyMan when not descriptor wallet
         if (!walletInstance->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
             walletInstance->SetupLegacyScriptPubKeyMan();
         }
 
         if (!(wallet_creation_flags &
               (WALLET_FLAG_DISABLE_PRIVATE_KEYS | WALLET_FLAG_BLANK_WALLET))) {
             LOCK(walletInstance->cs_wallet);
             if (walletInstance->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
                 walletInstance->SetupDescriptorScriptPubKeyMans();
                 // SetupDescriptorScriptPubKeyMans already calls SetupGeneration
                 // for us so we don't need to call SetupGeneration separately
             } else {
                 // Legacy wallets need SetupGeneration here.
                 for (auto spk_man :
                      walletInstance->GetActiveScriptPubKeyMans()) {
                     if (!spk_man->SetupGeneration()) {
                         error = _("Unable to generate initial keys");
                         return nullptr;
                     }
                 }
             }
         }
 
         walletInstance->chainStateFlushed(chain.getTipLocator());
     } else if (wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS) {
         // Make it impossible to disable private keys after creation
         error = strprintf(_("Error loading %s: Private keys can only be "
                             "disabled during creation"),
                           walletFile);
         return nullptr;
     } else if (walletInstance->IsWalletFlagSet(
                    WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         for (auto spk_man : walletInstance->GetActiveScriptPubKeyMans()) {
             if (spk_man->HavePrivateKeys()) {
                 warnings.push_back(
                     strprintf(_("Warning: Private keys detected in wallet {%s} "
                                 "with disabled private keys"),
                               walletFile));
             }
         }
     }
 
     if (gArgs.IsArgSet("-mintxfee")) {
         Amount n = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-mintxfee", ""), n) ||
             n == Amount::zero()) {
             error = AmountErrMsg("mintxfee", gArgs.GetArg("-mintxfee", ""));
             return nullptr;
         }
         if (n > HIGH_TX_FEE_PER_KB) {
             warnings.push_back(AmountHighWarn("-mintxfee") + Untranslated(" ") +
                                _("This is the minimum transaction fee you pay "
                                  "on every transaction."));
         }
         walletInstance->m_min_fee = CFeeRate(n);
     }
 
     if (gArgs.IsArgSet("-maxapsfee")) {
         Amount n = Amount::zero();
         if (gArgs.GetArg("-maxapsfee", "") == "-1") {
             n = -1 * SATOSHI;
         } else if (!ParseMoney(gArgs.GetArg("-maxapsfee", ""), n)) {
             error = AmountErrMsg("maxapsfee", gArgs.GetArg("-maxapsfee", ""));
             return nullptr;
         }
         if (n > HIGH_APS_FEE) {
             warnings.push_back(
                 AmountHighWarn("-maxapsfee") + Untranslated(" ") +
                 _("This is the maximum transaction fee you pay to prioritize "
                   "partial spend avoidance over regular coin selection."));
         }
         walletInstance->m_max_aps_fee = n;
     }
 
     if (gArgs.IsArgSet("-fallbackfee")) {
         Amount nFeePerK = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-fallbackfee", ""), nFeePerK)) {
             error =
                 strprintf(_("Invalid amount for -fallbackfee=<amount>: '%s'"),
                           gArgs.GetArg("-fallbackfee", ""));
             return nullptr;
         }
         if (nFeePerK > HIGH_TX_FEE_PER_KB) {
             warnings.push_back(AmountHighWarn("-fallbackfee") +
                                Untranslated(" ") +
                                _("This is the transaction fee you may pay when "
                                  "fee estimates are not available."));
         }
         walletInstance->m_fallback_fee = CFeeRate(nFeePerK);
     }
     // Disable fallback fee in case value was set to 0, enable if non-null value
     walletInstance->m_allow_fallback_fee =
         walletInstance->m_fallback_fee.GetFeePerK() != Amount::zero();
 
     if (gArgs.IsArgSet("-paytxfee")) {
         Amount nFeePerK = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-paytxfee", ""), nFeePerK)) {
             error = AmountErrMsg("paytxfee", gArgs.GetArg("-paytxfee", ""));
             return nullptr;
         }
         if (nFeePerK > HIGH_TX_FEE_PER_KB) {
             warnings.push_back(AmountHighWarn("-paytxfee") + Untranslated(" ") +
                                _("This is the transaction fee you will pay if "
                                  "you send a transaction."));
         }
         walletInstance->m_pay_tx_fee = CFeeRate(nFeePerK, 1000);
         if (walletInstance->m_pay_tx_fee < chain.relayMinFee()) {
             error = strprintf(_("Invalid amount for -paytxfee=<amount>: '%s' "
                                 "(must be at least %s)"),
                               gArgs.GetArg("-paytxfee", ""),
                               chain.relayMinFee().ToString());
             return nullptr;
         }
     }
 
     if (gArgs.IsArgSet("-maxtxfee")) {
         Amount nMaxFee = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-maxtxfee", ""), nMaxFee)) {
             error = AmountErrMsg("maxtxfee", gArgs.GetArg("-maxtxfee", ""));
             return nullptr;
         }
         if (nMaxFee > HIGH_MAX_TX_FEE) {
             warnings.push_back(_("-maxtxfee is set very high! Fees this large "
                                  "could be paid on a single transaction."));
         }
         if (CFeeRate(nMaxFee, 1000) < chain.relayMinFee()) {
             error = strprintf(
                 _("Invalid amount for -maxtxfee=<amount>: '%s' (must be at "
                   "least the minrelay fee of %s to prevent stuck "
                   "transactions)"),
                 gArgs.GetArg("-maxtxfee", ""), chain.relayMinFee().ToString());
             return nullptr;
         }
         walletInstance->m_default_max_tx_fee = nMaxFee;
     }
 
     if (chain.relayMinFee().GetFeePerK() > HIGH_TX_FEE_PER_KB) {
         warnings.push_back(
             AmountHighWarn("-minrelaytxfee") + Untranslated(" ") +
             _("The wallet will avoid paying less than the minimum relay fee."));
     }
 
     walletInstance->m_spend_zero_conf_change =
         gArgs.GetBoolArg("-spendzeroconfchange", DEFAULT_SPEND_ZEROCONF_CHANGE);
 
     walletInstance->m_default_address_type = DEFAULT_ADDRESS_TYPE;
     walletInstance->m_default_change_type = DEFAULT_CHANGE_TYPE;
 
     walletInstance->WalletLogPrintf("Wallet completed loading in %15dms\n",
                                     GetTimeMillis() - nStart);
 
     // Try to top up keypool. No-op if the wallet is locked.
     walletInstance->TopUpKeyPool();
 
     LOCK(walletInstance->cs_wallet);
 
     // Register wallet with validationinterface. It's done before rescan to
     // avoid missing block connections between end of rescan and validation
     // subscribing. Because of wallet lock being hold, block connection
     // notifications are going to be pending on the validation-side until lock
     // release. It's likely to have block processing duplicata (if rescan block
     // range overlaps with notification one) but we guarantee at least than
     // wallet state is correct after notifications delivery. This is temporary
     // until rescan and notifications delivery are unified under same interface.
     walletInstance->m_chain_notifications_handler =
         walletInstance->chain().handleNotifications(walletInstance);
 
     int rescan_height = 0;
     if (!gArgs.GetBoolArg("-rescan", false)) {
         WalletBatch batch(*walletInstance->database);
         CBlockLocator locator;
         if (batch.ReadBestBlock(locator)) {
             if (const std::optional<int> fork_height =
                     chain.findLocatorFork(locator)) {
                 rescan_height = *fork_height;
             }
         }
     }
 
     const std::optional<int> tip_height = chain.getHeight();
     if (tip_height) {
         walletInstance->m_last_block_processed =
             chain.getBlockHash(*tip_height);
         walletInstance->m_last_block_processed_height = *tip_height;
     } else {
         walletInstance->m_last_block_processed.SetNull();
         walletInstance->m_last_block_processed_height = -1;
     }
 
     if (tip_height && *tip_height != rescan_height) {
         // We can't rescan beyond non-pruned blocks, stop and throw an error.
         // This might happen if a user uses an old wallet within a pruned node
         // or if they ran -disablewallet for a longer time, then decided to
         // re-enable
         if (chain.havePruned()) {
             // Exit early and print an error.
             // If a block is pruned after this check, we will load the wallet,
             // but fail the rescan with a generic error.
             int block_height = *tip_height;
             while (block_height > 0 &&
                    chain.haveBlockOnDisk(block_height - 1) &&
                    rescan_height != block_height) {
                 --block_height;
             }
 
             if (rescan_height != block_height) {
                 error = _("Prune: last wallet synchronisation goes beyond "
                           "pruned data. You need to -reindex (download the "
                           "whole blockchain again in case of pruned node)");
                 return nullptr;
             }
         }
 
         chain.initMessage(_("Rescanning...").translated);
         walletInstance->WalletLogPrintf(
             "Rescanning last %i blocks (from block %i)...\n",
             *tip_height - rescan_height, rescan_height);
 
         // No need to read and scan block if block was created before our wallet
         // birthday (as adjusted for block time variability)
         std::optional<int64_t> time_first_key;
         for (auto spk_man : walletInstance->GetAllScriptPubKeyMans()) {
             int64_t time = spk_man->GetTimeFirstKey();
             if (!time_first_key || time < *time_first_key) {
                 time_first_key = time;
             }
         }
         if (time_first_key) {
             if (std::optional<int> first_block =
                     chain.findFirstBlockWithTimeAndHeight(
                         *time_first_key - TIMESTAMP_WINDOW, rescan_height,
                         nullptr)) {
                 rescan_height = *first_block;
             }
         }
 
         {
             WalletRescanReserver reserver(*walletInstance);
             if (!reserver.reserve() ||
                 (ScanResult::SUCCESS !=
                  walletInstance
                      ->ScanForWalletTransactions(
                          chain.getBlockHash(rescan_height), rescan_height,
                          {} /* max height */, reserver, true /* update */)
                      .status)) {
                 error = _("Failed to rescan the wallet during initialization");
                 return nullptr;
             }
         }
         walletInstance->chainStateFlushed(chain.getTipLocator());
         walletInstance->database->IncrementUpdateCounter();
 
         // Restore wallet transaction metadata after -zapwallettxes=1
         if (gArgs.GetBoolArg("-zapwallettxes", false) &&
             gArgs.GetArg("-zapwallettxes", "1") != "2") {
             WalletBatch batch(*walletInstance->database);
 
             for (const CWalletTx &wtxOld : vWtx) {
                 const TxId txid = wtxOld.GetId();
                 std::map<TxId, CWalletTx>::iterator mi =
                     walletInstance->mapWallet.find(txid);
                 if (mi != walletInstance->mapWallet.end()) {
                     const CWalletTx *copyFrom = &wtxOld;
                     CWalletTx *copyTo = &mi->second;
                     copyTo->mapValue = copyFrom->mapValue;
                     copyTo->vOrderForm = copyFrom->vOrderForm;
                     copyTo->nTimeReceived = copyFrom->nTimeReceived;
                     copyTo->nTimeSmart = copyFrom->nTimeSmart;
                     copyTo->fFromMe = copyFrom->fFromMe;
                     copyTo->nOrderPos = copyFrom->nOrderPos;
                     batch.WriteTx(*copyTo);
                 }
             }
         }
     }
 
     {
         LOCK(cs_wallets);
         for (auto &load_wallet : g_load_wallet_fns) {
             load_wallet(interfaces::MakeWallet(walletInstance));
         }
     }
 
     walletInstance->SetBroadcastTransactions(
         gArgs.GetBoolArg("-walletbroadcast", DEFAULT_WALLETBROADCAST));
 
     walletInstance->WalletLogPrintf("setKeyPool.size() = %u\n",
                                     walletInstance->GetKeyPoolSize());
     walletInstance->WalletLogPrintf("mapWallet.size() = %u\n",
                                     walletInstance->mapWallet.size());
     walletInstance->WalletLogPrintf("m_address_book.size() = %u\n",
                                     walletInstance->m_address_book.size());
 
     return walletInstance;
 }
 
 const CAddressBookData *
 CWallet::FindAddressBookEntry(const CTxDestination &dest,
                               bool allow_change) const {
     const auto &address_book_it = m_address_book.find(dest);
     if (address_book_it == m_address_book.end()) {
         return nullptr;
     }
     if ((!allow_change) && address_book_it->second.IsChange()) {
         return nullptr;
     }
     return &address_book_it->second;
 }
 
 bool CWallet::UpgradeWallet(int version, bilingual_str &error,
                             std::vector<bilingual_str> &warnings) {
     int prev_version = GetVersion();
     int nMaxVersion = version;
     // The -upgradewallet without argument case
     if (nMaxVersion == 0) {
         WalletLogPrintf("Performing wallet upgrade to %i\n", FEATURE_LATEST);
         nMaxVersion = FEATURE_LATEST;
         // permanently upgrade the wallet immediately
         SetMinVersion(FEATURE_LATEST);
     } else {
         WalletLogPrintf("Allowing wallet upgrade up to %i\n", nMaxVersion);
     }
 
     if (nMaxVersion < GetVersion()) {
         error = _("Cannot downgrade wallet");
         return false;
     }
 
     SetMaxVersion(nMaxVersion);
 
     LOCK(cs_wallet);
 
     // Do not upgrade versions to any version between HD_SPLIT and
     // FEATURE_PRE_SPLIT_KEYPOOL unless already supporting HD_SPLIT
     int max_version = GetVersion();
     if (!CanSupportFeature(FEATURE_HD_SPLIT) &&
         max_version >= FEATURE_HD_SPLIT &&
         max_version < FEATURE_PRE_SPLIT_KEYPOOL) {
         error = _("Cannot upgrade a non HD split wallet without upgrading to "
                   "support pre split keypool. Please use version 200300 or no "
                   "version specified.");
         return false;
     }
 
     for (auto spk_man : GetActiveScriptPubKeyMans()) {
         if (!spk_man->Upgrade(prev_version, error)) {
             return false;
         }
     }
 
     return true;
 }
 
 void CWallet::postInitProcess() {
     LOCK(cs_wallet);
 
     // Add wallet transactions that aren't already in a block to mempool.
     // Do this here as mempool requires genesis block to be loaded.
     ReacceptWalletTransactions();
 
     // Update wallet transactions with current mempool transactions.
     chain().requestMempoolTransactions(*this);
 }
 
 bool CWallet::BackupWallet(const std::string &strDest) const {
     return database->Backup(strDest);
 }
 
 CKeyPool::CKeyPool() {
     nTime = GetTime();
     fInternal = false;
     m_pre_split = false;
 }
 
 CKeyPool::CKeyPool(const CPubKey &vchPubKeyIn, bool internalIn) {
     nTime = GetTime();
     vchPubKey = vchPubKeyIn;
     fInternal = internalIn;
     m_pre_split = false;
 }
 
 int CWalletTx::GetDepthInMainChain() const {
     assert(pwallet != nullptr);
     AssertLockHeld(pwallet->cs_wallet);
     if (isUnconfirmed() || isAbandoned()) {
         return 0;
     }
 
     return (pwallet->GetLastBlockHeight() - m_confirm.block_height + 1) *
            (isConflicted() ? -1 : 1);
 }
 
 int CWalletTx::GetBlocksToMaturity() const {
     if (!IsCoinBase()) {
         return 0;
     }
 
     int chain_depth = GetDepthInMainChain();
     // coinbase tx should not be conflicted
     assert(chain_depth >= 0);
     return std::max(0, (COINBASE_MATURITY + 1) - chain_depth);
 }
 
 bool CWalletTx::IsImmatureCoinBase() const {
     // note GetBlocksToMaturity is 0 for non-coinbase tx
     return GetBlocksToMaturity() > 0;
 }
 
 std::vector<OutputGroup>
 CWallet::GroupOutputs(const std::vector<COutput> &outputs, bool single_coin,
                       const size_t max_ancestors) const {
     std::vector<OutputGroup> groups;
     std::map<CTxDestination, OutputGroup> gmap;
     std::set<CTxDestination> full_groups;
 
     for (const auto &output : outputs) {
         if (output.fSpendable) {
             CTxDestination dst;
             CInputCoin input_coin = output.GetInputCoin();
 
             size_t ancestors, descendants;
             chain().getTransactionAncestry(output.tx->GetId(), ancestors,
                                            descendants);
             if (!single_coin &&
                 ExtractDestination(output.tx->tx->vout[output.i].scriptPubKey,
                                    dst)) {
                 auto it = gmap.find(dst);
                 if (it != gmap.end()) {
                     // Limit output groups to no more than
                     // OUTPUT_GROUP_MAX_ENTRIES number of entries, to protect
                     // against inadvertently creating a too-large transaction
                     // when using -avoidpartialspends to prevent breaking
                     // consensus or surprising users with a very high amount of
                     // fees.
                     if (it->second.m_outputs.size() >=
                         OUTPUT_GROUP_MAX_ENTRIES) {
                         groups.push_back(it->second);
                         it->second = OutputGroup{};
                         full_groups.insert(dst);
                     }
                     it->second.Insert(input_coin, output.nDepth,
                                       output.tx->IsFromMe(ISMINE_ALL),
                                       ancestors, descendants);
                 } else {
                     gmap[dst].Insert(input_coin, output.nDepth,
                                      output.tx->IsFromMe(ISMINE_ALL), ancestors,
                                      descendants);
                 }
             } else {
                 groups.emplace_back(input_coin, output.nDepth,
                                     output.tx->IsFromMe(ISMINE_ALL), ancestors,
                                     descendants);
             }
         }
     }
     if (!single_coin) {
         for (auto &it : gmap) {
             auto &group = it.second;
             if (full_groups.count(it.first) > 0) {
                 // Make this unattractive as we want coin selection to avoid it
                 // if possible
                 group.m_ancestors = max_ancestors - 1;
             }
             groups.push_back(group);
         }
     }
     return groups;
 }
 
 bool CWallet::IsCrypted() const {
     return HasEncryptionKeys();
 }
 
 bool CWallet::IsLocked() const {
     if (!IsCrypted()) {
         return false;
     }
     LOCK(cs_wallet);
     return vMasterKey.empty();
 }
 
 bool CWallet::Lock() {
     if (!IsCrypted()) {
         return false;
     }
 
     {
         LOCK(cs_wallet);
         vMasterKey.clear();
     }
 
     NotifyStatusChanged(this);
     return true;
 }
 
 bool CWallet::Unlock(const CKeyingMaterial &vMasterKeyIn, bool accept_no_keys) {
     {
         LOCK(cs_wallet);
         for (const auto &spk_man_pair : m_spk_managers) {
             if (!spk_man_pair.second->CheckDecryptionKey(vMasterKeyIn,
                                                          accept_no_keys)) {
                 return false;
             }
         }
         vMasterKey = vMasterKeyIn;
     }
     NotifyStatusChanged(this);
     return true;
 }
 
 std::set<ScriptPubKeyMan *> CWallet::GetActiveScriptPubKeyMans() const {
     std::set<ScriptPubKeyMan *> spk_mans;
     for (bool internal : {false, true}) {
         for (OutputType t : OUTPUT_TYPES) {
             auto spk_man = GetScriptPubKeyMan(t, internal);
             if (spk_man) {
                 spk_mans.insert(spk_man);
             }
         }
     }
     return spk_mans;
 }
 
 std::set<ScriptPubKeyMan *> CWallet::GetAllScriptPubKeyMans() const {
     std::set<ScriptPubKeyMan *> spk_mans;
     for (const auto &spk_man_pair : m_spk_managers) {
         spk_mans.insert(spk_man_pair.second.get());
     }
     return spk_mans;
 }
 
 ScriptPubKeyMan *CWallet::GetScriptPubKeyMan(const OutputType &type,
                                              bool internal) const {
     const std::map<OutputType, ScriptPubKeyMan *> &spk_managers =
         internal ? m_internal_spk_managers : m_external_spk_managers;
     std::map<OutputType, ScriptPubKeyMan *>::const_iterator it =
         spk_managers.find(type);
     if (it == spk_managers.end()) {
         WalletLogPrintf(
             "%s scriptPubKey Manager for output type %d does not exist\n",
             internal ? "Internal" : "External", static_cast<int>(type));
         return nullptr;
     }
     return it->second;
 }
 
 std::set<ScriptPubKeyMan *>
 CWallet::GetScriptPubKeyMans(const CScript &script,
                              SignatureData &sigdata) const {
     std::set<ScriptPubKeyMan *> spk_mans;
     for (const auto &spk_man_pair : m_spk_managers) {
         if (spk_man_pair.second->CanProvide(script, sigdata)) {
             spk_mans.insert(spk_man_pair.second.get());
         }
     }
     return spk_mans;
 }
 
 ScriptPubKeyMan *CWallet::GetScriptPubKeyMan(const CScript &script) const {
     SignatureData sigdata;
     for (const auto &spk_man_pair : m_spk_managers) {
         if (spk_man_pair.second->CanProvide(script, sigdata)) {
             return spk_man_pair.second.get();
         }
     }
     return nullptr;
 }
 
 ScriptPubKeyMan *CWallet::GetScriptPubKeyMan(const uint256 &id) const {
     if (m_spk_managers.count(id) > 0) {
         return m_spk_managers.at(id).get();
     }
     return nullptr;
 }
 
 std::unique_ptr<SigningProvider>
 CWallet::GetSolvingProvider(const CScript &script) const {
     SignatureData sigdata;
     return GetSolvingProvider(script, sigdata);
 }
 
 std::unique_ptr<SigningProvider>
 CWallet::GetSolvingProvider(const CScript &script,
                             SignatureData &sigdata) const {
     for (const auto &spk_man_pair : m_spk_managers) {
         if (spk_man_pair.second->CanProvide(script, sigdata)) {
             return spk_man_pair.second->GetSolvingProvider(script);
         }
     }
     return nullptr;
 }
 
 LegacyScriptPubKeyMan *CWallet::GetLegacyScriptPubKeyMan() const {
     if (IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
         return nullptr;
     }
     // Legacy wallets only have one ScriptPubKeyMan which is a
     // LegacyScriptPubKeyMan. Everything in m_internal_spk_managers and
     // m_external_spk_managers point to the same legacyScriptPubKeyMan.
     auto it = m_internal_spk_managers.find(OutputType::LEGACY);
     if (it == m_internal_spk_managers.end()) {
         return nullptr;
     }
     return dynamic_cast<LegacyScriptPubKeyMan *>(it->second);
 }
 
 LegacyScriptPubKeyMan *CWallet::GetOrCreateLegacyScriptPubKeyMan() {
     SetupLegacyScriptPubKeyMan();
     return GetLegacyScriptPubKeyMan();
 }
 
 void CWallet::SetupLegacyScriptPubKeyMan() {
     if (!m_internal_spk_managers.empty() || !m_external_spk_managers.empty() ||
         !m_spk_managers.empty() || IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
         return;
     }
 
     auto spk_manager =
         std::unique_ptr<ScriptPubKeyMan>(new LegacyScriptPubKeyMan(*this));
     for (const auto &type : OUTPUT_TYPES) {
         m_internal_spk_managers[type] = spk_manager.get();
         m_external_spk_managers[type] = spk_manager.get();
     }
     m_spk_managers[spk_manager->GetID()] = std::move(spk_manager);
 }
 
 const CKeyingMaterial &CWallet::GetEncryptionKey() const {
     return vMasterKey;
 }
 
 bool CWallet::HasEncryptionKeys() const {
     return !mapMasterKeys.empty();
 }
 
 void CWallet::ConnectScriptPubKeyManNotifiers() {
     for (const auto &spk_man : GetActiveScriptPubKeyMans()) {
         spk_man->NotifyWatchonlyChanged.connect(NotifyWatchonlyChanged);
         spk_man->NotifyCanGetAddressesChanged.connect(
             NotifyCanGetAddressesChanged);
     }
 }
 
 void CWallet::LoadDescriptorScriptPubKeyMan(uint256 id,
                                             WalletDescriptor &desc) {
     auto spk_manager = std::unique_ptr<ScriptPubKeyMan>(
         new DescriptorScriptPubKeyMan(*this, desc));
     m_spk_managers[id] = std::move(spk_manager);
 }
 
 void CWallet::SetupDescriptorScriptPubKeyMans() {
     AssertLockHeld(cs_wallet);
 
     // Make a seed
     CKey seed_key;
     seed_key.MakeNewKey(true);
     CPubKey seed = seed_key.GetPubKey();
     assert(seed_key.VerifyPubKey(seed));
 
     // Get the extended key
     CExtKey master_key;
     master_key.SetSeed(seed_key.begin(), seed_key.size());
 
     for (bool internal : {false, true}) {
         for (OutputType t : OUTPUT_TYPES) {
             auto spk_manager =
                 std::make_unique<DescriptorScriptPubKeyMan>(*this, t, internal);
             if (IsCrypted()) {
                 if (IsLocked()) {
                     throw std::runtime_error(
                         std::string(__func__) +
                         ": Wallet is locked, cannot setup new descriptors");
                 }
                 if (!spk_manager->CheckDecryptionKey(vMasterKey) &&
                     !spk_manager->Encrypt(vMasterKey, nullptr)) {
                     throw std::runtime_error(
                         std::string(__func__) +
                         ": Could not encrypt new descriptors");
                 }
             }
             spk_manager->SetupDescriptorGeneration(master_key);
             uint256 id = spk_manager->GetID();
             m_spk_managers[id] = std::move(spk_manager);
             SetActiveScriptPubKeyMan(id, t, internal);
         }
     }
 }
 
 void CWallet::SetActiveScriptPubKeyMan(uint256 id, OutputType type,
                                        bool internal, bool memonly) {
     WalletLogPrintf(
         "Setting spkMan to active: id = %s, type = %d, internal = %d\n",
         id.ToString(), static_cast<int>(type), static_cast<int>(internal));
     auto &spk_mans =
         internal ? m_internal_spk_managers : m_external_spk_managers;
     auto spk_man = m_spk_managers.at(id).get();
     spk_man->SetType(type, internal);
     spk_mans[type] = spk_man;
 
     if (!memonly) {
         WalletBatch batch(*database);
         if (!batch.WriteActiveScriptPubKeyMan(static_cast<uint8_t>(type), id,
                                               internal)) {
             throw std::runtime_error(
                 std::string(__func__) +
                 ": writing active ScriptPubKeyMan id failed");
         }
     }
     NotifyCanGetAddressesChanged();
 }
 
 bool CWallet::IsLegacy() const {
     if (m_internal_spk_managers.count(OutputType::LEGACY) == 0) {
         return false;
     }
     auto spk_man = dynamic_cast<LegacyScriptPubKeyMan *>(
         m_internal_spk_managers.at(OutputType::LEGACY));
     return spk_man != nullptr;
 }
 
 DescriptorScriptPubKeyMan *
 CWallet::GetDescriptorScriptPubKeyMan(const WalletDescriptor &desc) const {
     for (auto &spk_man_pair : m_spk_managers) {
         // Try to downcast to DescriptorScriptPubKeyMan then check if the
         // descriptors match
         DescriptorScriptPubKeyMan *spk_manager =
             dynamic_cast<DescriptorScriptPubKeyMan *>(
                 spk_man_pair.second.get());
         if (spk_manager != nullptr && spk_manager->HasWalletDescriptor(desc)) {
             return spk_manager;
         }
     }
 
     return nullptr;
 }
 
 ScriptPubKeyMan *
 CWallet::AddWalletDescriptor(WalletDescriptor &desc,
                              const FlatSigningProvider &signing_provider,
                              const std::string &label) {
     if (!IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
         WalletLogPrintf(
             "Cannot add WalletDescriptor to a non-descriptor wallet\n");
         return nullptr;
     }
 
     LOCK(cs_wallet);
     auto new_spk_man = std::make_unique<DescriptorScriptPubKeyMan>(*this, desc);
 
     // If we already have this descriptor, remove it from the maps but add the
     // existing cache to desc
     auto old_spk_man = GetDescriptorScriptPubKeyMan(desc);
     if (old_spk_man) {
         WalletLogPrintf("Update existing descriptor: %s\n",
                         desc.descriptor->ToString());
 
         {
             LOCK(old_spk_man->cs_desc_man);
             new_spk_man->SetCache(old_spk_man->GetWalletDescriptor().cache);
         }
 
         // Remove from maps of active spkMans
         auto old_spk_man_id = old_spk_man->GetID();
         for (bool internal : {false, true}) {
             for (OutputType t : OUTPUT_TYPES) {
                 auto active_spk_man = GetScriptPubKeyMan(t, internal);
                 if (active_spk_man &&
                     active_spk_man->GetID() == old_spk_man_id) {
                     if (internal) {
                         m_internal_spk_managers.erase(t);
                     } else {
                         m_external_spk_managers.erase(t);
                     }
                     break;
                 }
             }
         }
         m_spk_managers.erase(old_spk_man_id);
     }
 
     // Add the private keys to the descriptor
     for (const auto &entry : signing_provider.keys) {
         const CKey &key = entry.second;
         new_spk_man->AddDescriptorKey(key, key.GetPubKey());
     }
 
     // Top up key pool, the manager will generate new scriptPubKeys internally
     new_spk_man->TopUp();
 
     // Apply the label if necessary
     // Note: we disable labels for ranged descriptors
     if (!desc.descriptor->IsRange()) {
         auto script_pub_keys = new_spk_man->GetScriptPubKeys();
         if (script_pub_keys.empty()) {
             WalletLogPrintf(
                 "Could not generate scriptPubKeys (cache is empty)\n");
             return nullptr;
         }
 
         CTxDestination dest;
         if (ExtractDestination(script_pub_keys.at(0), dest)) {
             SetAddressBook(dest, label, "receive");
         }
     }
 
     // Save the descriptor to memory
     auto ret = new_spk_man.get();
     m_spk_managers[new_spk_man->GetID()] = std::move(new_spk_man);
 
     // Save the descriptor to DB
     ret->WriteDescriptor();
 
     return ret;
 }
diff --git a/test/functional/rpc_psbt.py b/test/functional/rpc_psbt.py
index 8b8b55f75..f09d460e9 100755
--- a/test/functional/rpc_psbt.py
+++ b/test/functional/rpc_psbt.py
@@ -1,448 +1,451 @@
 #!/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_approx,
     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
         self.supports_cli = False
 
     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']
 
         # If inputs are specified, do not automatically add more:
         utxo1 = self.nodes[0].listunspent()[0]
         assert_raises_rpc_error(-4,
                                 "Insufficient funds",
                                 self.nodes[0].walletcreatefundedpsbt,
                                 [{"txid": utxo1['txid'],
                                   "vout": utxo1['vout']}],
                                 {self.nodes[2].getnewaddress(): 90})
 
         psbtx1 = self.nodes[0].walletcreatefundedpsbt([{"txid": utxo1['txid'], "vout": utxo1['vout']}], {
                                                       self.nodes[2].getnewaddress(): 90}, 0, {"add_inputs": True})['psbt']
         assert_equal(len(self.nodes[0].decodepsbt(psbtx1)['tx']['vin']), 2)
 
         # 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)
+        # Make sure it has UTXOs
+        decoded = self.nodes[1].decodepsbt(walletprocesspsbt_out['psbt'])
+        assert 'utxo' in decoded['inputs'][0]
         assert_equal(walletprocesspsbt_out['complete'], True)
         self.nodes[1].sendrawtransaction(
             self.nodes[1].finalizepsbt(walletprocesspsbt_out['psbt'])['hex'])
 
         # feeRate of 0.1 BCH / KB produces a total fee slightly below -maxtxfee
         res = self.nodes[1].walletcreatefundedpsbt(
             [
                 {
                     "txid": txid, "vout": p2sh_pos}, {
                     "txid": txid, "vout": p2pkh_pos}], {
                         self.nodes[1].getnewaddress(): 29.99}, 0, {
                             "feeRate": 0.1, "add_inputs": True})
         assert_approx(res["fee"], 0.065, 0.005)
 
         # feeRate of 10 BCH / KB produces a total fee well above -maxtxfee
         # previously this was silently capped at -maxtxfee
         assert_raises_rpc_error(-4,
                                 "Fee exceeds maximum configured by -maxtxfee",
                                 self.nodes[1].walletcreatefundedpsbt,
                                 [{"txid": txid,
                                   "vout": p2sh_pos},
                                  {"txid": txid,
                                      "vout": p2pkh_pos}],
                                 {self.nodes[1].getnewaddress(): 29.99},
                                 0,
                                 {"feeRate": 10,
                                     "add_inputs": True})
         assert_raises_rpc_error(-4,
                                 "Fee exceeds maximum configured by -maxtxfee",
                                 self.nodes[1].walletcreatefundedpsbt,
                                 [{"txid": txid,
                                   "vout": p2sh_pos},
                                     {"txid": txid,
                                      "vout": p2pkh_pos}],
                                 {self.nodes[1].getnewaddress(): 1},
                                 0,
                                 {"feeRate": 10,
                                     "add_inputs": False})
 
         # 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 non-psbt with signatures cannot be converted
         # Error is "Inputs must not have scriptSigs"
         signedtx = self.nodes[0].signrawtransactionwithwallet(rawtx['hex'])
         assert_raises_rpc_error(-22,
                                 "",
                                 self.nodes[0].converttopsbt,
                                 signedtx['hex'])
         assert_raises_rpc_error(-22,
                                 "",
                                 self.nodes[0].converttopsbt,
                                 signedtx['hex'],
                                 False)
         # 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, False, "ALL|FORKID")['psbt']
         psbt1_decoded = self.nodes[0].decodepsbt(psbt1)
         assert psbt1_decoded['inputs'][0] and not psbt1_decoded['inputs'][1]
         # Check that BIP32 path was added
         assert "bip32_derivs" in psbt1_decoded['inputs'][0]
         psbt2 = self.nodes[2].walletprocesspsbt(
             psbt_orig, False, "ALL|FORKID", False)['psbt']
         psbt2_decoded = self.nodes[0].decodepsbt(psbt2)
         assert not psbt2_decoded['inputs'][0] and psbt2_decoded['inputs'][1]
         # Check that BIP32 paths were not added
         assert "bip32_derivs" not in psbt2_decoded['inputs'][1]
 
         # Sign PSBTs (workaround issue #18039)
         psbt1 = self.nodes[1].walletprocesspsbt(psbt_orig)['psbt']
         psbt2 = self.nodes[2].walletprocesspsbt(psbt_orig)['psbt']
 
         # 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()
 
         block_height = self.nodes[0].getblockcount()
         unspent = self.nodes[0].listunspent()[0]
 
         # Make sure change address wallet does not have P2SH innerscript access to results in success
         # when attempting BnB coin selection
         self.nodes[0].walletcreatefundedpsbt(
             [],
             [{self.nodes[2].getnewaddress():unspent["amount"] + 1}],
             block_height + 2,
             {"changeAddress": self.nodes[1].getnewaddress()},
             False)
 
         # 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}], 0, {"add_inputs": True})
         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'])
 
         # Empty combiner test
         assert_raises_rpc_error(-8,
                                 "Parameter 'txs' cannot be empty",
                                 self.nodes[0].combinepsbt,
                                 [])
 
         # 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()
 
         def test_psbt_input_keys(psbt_input, keys):
             """Check that the psbt input has only the expected keys."""
             assert_equal(set(keys), set(psbt_input.keys()))
 
         # Create a PSBT. None of the inputs are filled initially
         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)
         test_psbt_input_keys(decoded['inputs'][0], [])
         test_psbt_input_keys(decoded['inputs'][1], [])
         test_psbt_input_keys(decoded['inputs'][2], [])
 
         # Update a PSBT with UTXOs from the node
         updated = self.nodes[1].utxoupdatepsbt(psbt)
         decoded = self.nodes[1].decodepsbt(updated)
         test_psbt_input_keys(decoded['inputs'][1], [])
         test_psbt_input_keys(decoded['inputs'][2], [])
 
         # Try again, now while providing descriptors
         descs = [self.nodes[1].getaddressinfo(addr)['desc'] for addr in [
             addr1, addr2, addr3]]
         updated = self.nodes[1].utxoupdatepsbt(psbt=psbt, descriptors=descs)
         decoded = self.nodes[1].decodepsbt(updated)
         test_psbt_input_keys(decoded['inputs'][1], [])
 
         # 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])
 
         # Check that joining shuffles the inputs and outputs
         # 10 attempts should be enough to get a shuffled join
         shuffled = False
         for i in range(0, 10):
             shuffled_joined = self.nodes[0].joinpsbts([psbt, psbt2])
             shuffled |= joined != shuffled_joined
             if shuffled:
                 break
         assert shuffled
 
         # 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.001') 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'
 
         self.log.info(
             "PSBT spending unspendable outputs should have error message and Creator as next")
         analysis = self.nodes[0].analyzepsbt(
             'cHNidP8BAJoCAAAAAljoeiG1ba8MI76OcHBFbDNvfLqlyHV5JPVFiHuyq911AAAAAAD/////g40EJ9DsZQpoqka7CwmK6kQiwHGyyng1Kgd5WdB86h0BAAAAAP////8CcKrwCAAAAAAWAEHYXCtx0AYLCcmIauuBXlCZHdoSTQDh9QUAAAAAFv8/wADXYP/7//////8JxOh0LR2HAI8AAAAAAAEAIADC6wsAAAAAF2oUt/X69ELjeX2nTof+fZ10l+OyAokDAQcJAwEHEAABAACAAAEAIADC6wsAAAAAF2oUt/X69ELjeX2nTof+fZ10l+OyAokDAQcJAwEHENkMak8AAAAA')
         assert_equal(analysis['next'], 'creator')
         assert_equal(
             analysis['error'],
             'PSBT is not valid. Input 0 spends unspendable output')
 
         self.log.info(
             "PSBT with invalid values should have error message and Creator as next")
         analysis = self.nodes[0].analyzepsbt(
             'cHNidP8BAHECAAAAAfA00BFgAm6tp86RowwH6BMImQNL5zXUcTT97XoLGz0BAAAAAAD/////AgD5ApUAAAAAFgAUKNw0x8HRctAgmvoevm4u1SbN7XL87QKVAAAAABYAFPck4gF7iL4NL4wtfRAKgQbghiTUAAAAAAABAB8AgIFq49AHABYAFJUDtxf2PHo641HEOBOAIvFMNTr2AAAA')
         assert_equal(analysis['next'], 'creator')
         assert_equal(
             analysis['error'],
             'PSBT is not valid. Input 0 has invalid value')
 
         analysis = self.nodes[0].analyzepsbt(
             'cHNidP8BAHECAAAAAfA00BFgAm6tp86RowwH6BMImQNL5zXUcTT97XoLGz0BAAAAAAD/////AgCAgWrj0AcAFgAUKNw0x8HRctAgmvoevm4u1SbN7XL87QKVAAAAABYAFPck4gF7iL4NL4wtfRAKgQbghiTUAAAAAAABAB8A8gUqAQAAABYAFJUDtxf2PHo641HEOBOAIvFMNTr2AAAA')
         assert_equal(analysis['next'], 'creator')
         assert_equal(
             analysis['error'],
             'PSBT is not valid. Output amount invalid')
 
 
 if __name__ == '__main__':
     PSBTTest().main()