diff --git a/src/wallet/scriptpubkeyman.cpp b/src/wallet/scriptpubkeyman.cpp
index 82efa3899..9a11dd483 100644
--- a/src/wallet/scriptpubkeyman.cpp
+++ b/src/wallet/scriptpubkeyman.cpp
@@ -1,1710 +1,1736 @@
 // 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 <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/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";
         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;
 }
 
 IsMineResult IsMineInner(const LegacyScriptPubKeyMan &keystore,
                          const CScript &scriptPubKey,
                          IsMineSigVersion sigversion) {
     IsMineResult ret = IsMineResult::NO;
 
     std::vector<valtype> vSolutions;
     txnouttype whichType = Solver(scriptPubKey, vSolutions);
 
     CKeyID keyID;
     switch (whichType) {
         case TX_NONSTANDARD:
         case TX_NULL_DATA:
             break;
         case TX_PUBKEY:
             keyID = CPubKey(vSolutions[0]).GetID();
             if (keystore.HaveKey(keyID)) {
                 ret = std::max(ret, IsMineResult::SPENDABLE);
             }
             break;
         case TX_PUBKEYHASH:
             keyID = CKeyID(uint160(vSolutions[0]));
             if (keystore.HaveKey(keyID)) {
                 ret = std::max(ret, IsMineResult::SPENDABLE);
             }
             break;
         case TX_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, IsMineInner(keystore, subscript,
                                                 IsMineSigVersion::P2SH));
             }
             break;
         }
         case TX_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) {
     if (IsMine(script) != ISMINE_NO) {
         // If it IsMine, we can always provide in some way
         return true;
     }
     if (HaveCScript(CScriptID(script))) {
         // We can still provide some stuff if we have the script, but IsMine
         // failed because we don't have keys
         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;
 }
 
 const 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 &it->second;
         }
     }
 
     CScript scriptPubKey = GetScriptForDestination(dest);
     auto it = m_script_metadata.find(CScriptID(scriptPubKey));
     if (it != m_script_metadata.end()) {
         return &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) == TX_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'/" +
                                  std::to_string(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'/" +
                                  std::to_string(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) {
     return false;
 }
 
 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) {
     return false;
 }
 
 bool DescriptorScriptPubKeyMan::Encrypt(const CKeyingMaterial &master_key,
                                         WalletBatch *batch) {
     return false;
 }
 
 bool DescriptorScriptPubKeyMan::GetReservedDestination(const OutputType type,
                                                        bool internal,
                                                        CTxDestination &address,
                                                        int64_t &index,
                                                        CKeyPool &keypool) {
     return false;
 }
 
 void DescriptorScriptPubKeyMan::ReturnDestination(int64_t index, bool internal,
                                                   const CTxDestination &addr) {}
 
 bool DescriptorScriptPubKeyMan::TopUp(unsigned int size) {
     return false;
 }
 
 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__);
         }
     }
 }
 
+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::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 {
     return GetTime();
 }
 
 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<SigningProvider>
 DescriptorScriptPubKeyMan::GetSolvingProvider(const CScript &script) const {
     return nullptr;
 }
 
 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 {
     return false;
 }
 
 SigningResult
 DescriptorScriptPubKeyMan::SignMessage(const std::string &message,
                                        const PKHash &pkhash,
                                        std::string &str_sig) const {
     return SigningResult::SIGNING_FAILED;
 }
 
 TransactionError
 DescriptorScriptPubKeyMan::FillPSBT(PartiallySignedTransaction &psbt,
                                     SigHashType sighash_type, bool sign,
                                     bool bip32derivs) const {
     return TransactionError::INVALID_PSBT;
 }
 
 const CKeyMetadata *
 DescriptorScriptPubKeyMan::GetMetadata(const CTxDestination &dest) const {
     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;
         }
     }
 }
 
 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;
 }
diff --git a/src/wallet/scriptpubkeyman.h b/src/wallet/scriptpubkeyman.h
index 3cc82b2ed..52f155f57 100644
--- a/src/wallet/scriptpubkeyman.h
+++ b/src/wallet/scriptpubkeyman.h
@@ -1,714 +1,717 @@
 // 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.
 
 #ifndef BITCOIN_WALLET_SCRIPTPUBKEYMAN_H
 #define BITCOIN_WALLET_SCRIPTPUBKEYMAN_H
 
 #include <psbt.h>
 #include <script/descriptor.h>
 #include <script/signingprovider.h>
 #include <script/standard.h>
 #include <util/error.h>
 #include <util/message.h>
 #include <wallet/crypter.h>
 #include <wallet/ismine.h>
 #include <wallet/walletdb.h>
 #include <wallet/walletutil.h>
 
 #include <boost/signals2/signal.hpp>
 
 enum class OutputType;
 struct bilingual_str;
 
 // Wallet storage things that ScriptPubKeyMans need in order to be able to store
 // things to the wallet database. It provides access to things that are part of
 // the entire wallet and not specific to a ScriptPubKeyMan such as wallet flags,
 // wallet version, encryption keys, encryption status, and the database itself.
 // This allows a ScriptPubKeyMan to have callbacks into CWallet without causing
 // a circular dependency. WalletStorage should be the same for all
 // ScriptPubKeyMans of a wallet.
 class WalletStorage {
 public:
     virtual ~WalletStorage() = default;
     virtual const std::string GetDisplayName() const = 0;
     virtual WalletDatabase &GetDatabase() = 0;
     virtual bool IsWalletFlagSet(uint64_t) const = 0;
     virtual void UnsetBlankWalletFlag(WalletBatch &) = 0;
     virtual bool CanSupportFeature(enum WalletFeature) const = 0;
     virtual void SetMinVersion(enum WalletFeature, WalletBatch * = nullptr,
                                bool = false) = 0;
     virtual const CKeyingMaterial &GetEncryptionKey() const = 0;
     virtual bool HasEncryptionKeys() const = 0;
     virtual bool IsLocked() const = 0;
 };
 
 //! Default for -keypool
 static const unsigned int DEFAULT_KEYPOOL_SIZE = 1000;
 
 std::vector<CKeyID> GetAffectedKeys(const CScript &spk,
                                     const SigningProvider &provider);
 
 /**
  * A key from a CWallet's keypool
  *
  * The wallet holds one (for pre HD-split wallets) or several keypools. These
  * are sets of keys that have not yet been used to provide addresses or receive
  * change.
  *
  * The Bitcoin ABC wallet was originally a collection of unrelated private
  * keys with their associated addresses. If a non-HD wallet generated a
  * key/address, gave that address out and then restored a backup from before
  * that key's generation, then any funds sent to that address would be
  * lost definitively.
  *
  * The keypool was implemented to avoid this scenario (commit: 10384941). The
  * wallet would generate a set of keys (100 by default). When a new public key
  * was required, either to give out as an address or to use in a change output,
  * it would be drawn from the keypool. The keypool would then be topped up to
  * maintain 100 keys. This ensured that as long as the wallet hadn't used more
  * than 100 keys since the previous backup, all funds would be safe, since a
  * restored wallet would be able to scan for all owned addresses.
  *
  * A keypool also allowed encrypted wallets to give out addresses without
  * having to be decrypted to generate a new private key.
  *
  * With the introduction of HD wallets (commit: f1902510), the keypool
  * essentially became an address look-ahead pool. Restoring old backups can no
  * longer definitively lose funds as long as the addresses used were from the
  * wallet's HD seed (since all private keys can be rederived from the seed).
  * However, if many addresses were used since the backup, then the wallet may
  * not know how far ahead in the HD chain to look for its addresses. The
  * keypool is used to implement a 'gap limit'. The keypool maintains a set of
  * keys (by default 1000) ahead of the last used key and scans for the
  * addresses of those keys.  This avoids the risk of not seeing transactions
  * involving the wallet's addresses, or of re-using the same address.
  * In the unlikely case where none of the addresses in the `gap limit` are
  * used on-chain, the look-ahead will not be incremented to keep
  * a constant size and addresses beyond this range will not be detected by an
  * old backup. For this reason, it is not recommended to decrease keypool size
  * lower than default value.
  *
  * The HD-split wallet feature added a second keypool (commit: 02592f4c). There
  * is an external keypool (for addresses to hand out) and an internal keypool
  * (for change addresses).
  *
  * Keypool keys are stored in the wallet/keystore's keymap. The keypool data is
  * stored as sets of indexes in the wallet (setInternalKeyPool,
  * setExternalKeyPool and set_pre_split_keypool), and a map from the key to the
  * index (m_pool_key_to_index). The CKeyPool object is used to
  * serialize/deserialize the pool data to/from the database.
  */
 class CKeyPool {
 public:
     //! The time at which the key was generated. Set in AddKeypoolPubKeyWithDB
     int64_t nTime;
     //! The public key
     CPubKey vchPubKey;
     //! Whether this keypool entry is in the internal keypool (for change
     //! outputs)
     bool fInternal;
     //! Whether this key was generated for a keypool before the wallet was
     //! upgraded to HD-split
     bool m_pre_split;
 
     CKeyPool();
     CKeyPool(const CPubKey &vchPubKeyIn, bool internalIn);
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         int nVersion = s.GetVersion();
         if (!(s.GetType() & SER_GETHASH)) {
             READWRITE(nVersion);
         }
 
         READWRITE(nTime);
         READWRITE(vchPubKey);
         if (ser_action.ForRead()) {
             try {
                 READWRITE(fInternal);
             } catch (std::ios_base::failure &) {
                 /**
                  * flag as external address if we can't read the internal
                  * boolean (this will be the case for any wallet before the HD
                  * chain split version)
                  */
                 fInternal = false;
             }
             try {
                 READWRITE(m_pre_split);
             } catch (std::ios_base::failure &) {
                 /**
                  * flag as postsplit address if we can't read the m_pre_split
                  * boolean (this will be the case for any wallet that upgrades
                  * to HD chain split)
                  */
                 m_pre_split = false;
             }
         } else {
             READWRITE(fInternal);
             READWRITE(m_pre_split);
         }
     }
 };
 
 /*
  * A class implementing ScriptPubKeyMan manages some (or all) scriptPubKeys used
  * in a wallet. It contains the scripts and keys related to the scriptPubKeys it
  * manages. A ScriptPubKeyMan will be able to give out scriptPubKeys to be used,
  * as well as marking when a scriptPubKey has been used. It also handles when
  * and how to store a scriptPubKey and its related scripts and keys, including
  * encryption.
  */
 class ScriptPubKeyMan {
 protected:
     WalletStorage &m_storage;
 
 public:
     ScriptPubKeyMan(WalletStorage &storage) : m_storage(storage) {}
     virtual ~ScriptPubKeyMan(){};
     virtual bool GetNewDestination(const OutputType type, CTxDestination &dest,
                                    std::string &error) {
         return false;
     }
     virtual isminetype IsMine(const CScript &script) const { return ISMINE_NO; }
 
     //! Check that the given decryption key is valid for this ScriptPubKeyMan,
     //! i.e. it decrypts all of the keys handled by it.
     virtual bool CheckDecryptionKey(const CKeyingMaterial &master_key,
                                     bool accept_no_keys = false) {
         return false;
     }
     virtual bool Encrypt(const CKeyingMaterial &master_key,
                          WalletBatch *batch) {
         return false;
     }
 
     virtual bool GetReservedDestination(const OutputType type, bool internal,
                                         CTxDestination &address, int64_t &index,
                                         CKeyPool &keypool) {
         return false;
     }
     virtual void KeepDestination(int64_t index, const OutputType &type) {}
     virtual void ReturnDestination(int64_t index, bool internal,
                                    const CTxDestination &addr) {}
 
     /**
      * Fills internal address pool. Use within ScriptPubKeyMan implementations
      * should be used sparingly and only when something from the address pool is
      * removed, excluding GetNewDestination and GetReservedDestination. External
      * wallet code is primarily responsible for topping up prior to fetching new
      * addresses
      */
     virtual bool TopUp(unsigned int size = 0) { return false; }
 
     //! Mark unused addresses as being used
     virtual void MarkUnusedAddresses(const CScript &script) {}
 
     /**
      * Sets up the key generation stuff, i.e. generates new HD seeds and sets
      * them as active. Returns false if already setup or setup fails, true if
      * setup is successful Set force=true to make it re-setup if already setup,
      * used for upgrades
      */
     virtual bool SetupGeneration(bool force = false) { return false; }
 
     /* Returns true if HD is enabled */
     virtual bool IsHDEnabled() const { return false; }
 
     /**
      * Returns true if the wallet can give out new addresses. This means it has
      * keys in the keypool or can generate new keys.
      */
     virtual bool CanGetAddresses(bool internal = false) const { return false; }
 
     /** Upgrades the wallet to the specified version */
     virtual bool Upgrade(int prev_version, bilingual_str &error) {
         return false;
     }
 
     virtual bool HavePrivateKeys() const { return false; }
 
     //! The action to do when the DB needs rewrite
     virtual void RewriteDB() {}
 
     virtual int64_t GetOldestKeyPoolTime() const { return GetTime(); }
 
     virtual size_t KeypoolCountExternalKeys() const { return 0; }
     virtual unsigned int GetKeyPoolSize() const { return 0; }
 
     virtual int64_t GetTimeFirstKey() const { return 0; }
 
     virtual const CKeyMetadata *GetMetadata(const CTxDestination &dest) const {
         return nullptr;
     }
 
     virtual std::unique_ptr<SigningProvider>
     GetSolvingProvider(const CScript &script) const {
         return nullptr;
     }
 
     /**
      * Whether this ScriptPubKeyMan can provide a SigningProvider (via
      * GetSolvingProvider) that, combined with sigdata, can produce solving
      * data.
      */
     virtual bool CanProvide(const CScript &script, SignatureData &sigdata) {
         return false;
     }
 
     /**
      * Creates new signatures and adds them to the transaction. Returns whether
      * all inputs were signed
      */
     virtual bool
     SignTransaction(CMutableTransaction &tx,
                     const std::map<COutPoint, Coin> &coins, SigHashType sighash,
                     std::map<int, std::string> &input_errors) const {
         return false;
     }
     /** Sign a message with the given script */
     virtual SigningResult SignMessage(const std::string &message,
                                       const PKHash &pkhash,
                                       std::string &str_sig) const {
         return SigningResult::SIGNING_FAILED;
     };
     /**
      * Adds script and derivation path information to a PSBT, and optionally
      * signs it.
      */
     virtual TransactionError
     FillPSBT(PartiallySignedTransaction &psbt,
              SigHashType sighash_type = SigHashType().withForkId(),
              bool sign = true, bool bip32derivs = false) const {
         return TransactionError::INVALID_PSBT;
     }
 
     virtual uint256 GetID() const { return uint256(); }
 
     virtual void SetType(OutputType type, bool internal) {}
 
     /**
      * Prepends the wallet name in logging output to ease debugging in
      * multi-wallet use cases
      */
     template <typename... Params>
     void WalletLogPrintf(std::string fmt, Params... parameters) const {
         LogPrintf(("%s " + fmt).c_str(), m_storage.GetDisplayName(),
                   parameters...);
     };
 
     /** Watch-only address added */
     boost::signals2::signal<void(bool fHaveWatchOnly)> NotifyWatchonlyChanged;
 
     /** Keypool has new keys */
     boost::signals2::signal<void()> NotifyCanGetAddressesChanged;
 };
 
 class LegacyScriptPubKeyMan : public ScriptPubKeyMan,
                               public FillableSigningProvider {
 private:
     //! keeps track of whether Unlock has run a thorough check before
     bool fDecryptionThoroughlyChecked = false;
 
     using WatchOnlySet = std::set<CScript>;
     using WatchKeyMap = std::map<CKeyID, CPubKey>;
 
     WalletBatch *encrypted_batch GUARDED_BY(cs_KeyStore) = nullptr;
 
     using CryptedKeyMap =
         std::map<CKeyID, std::pair<CPubKey, std::vector<uint8_t>>>;
 
     CryptedKeyMap mapCryptedKeys GUARDED_BY(cs_KeyStore);
     WatchOnlySet setWatchOnly GUARDED_BY(cs_KeyStore);
     WatchKeyMap mapWatchKeys GUARDED_BY(cs_KeyStore);
 
     int64_t nTimeFirstKey GUARDED_BY(cs_KeyStore) = 0;
 
     bool AddKeyPubKeyInner(const CKey &key, const CPubKey &pubkey);
     bool AddCryptedKeyInner(const CPubKey &vchPubKey,
                             const std::vector<uint8_t> &vchCryptedSecret);
 
     /**
      * Private version of AddWatchOnly method which does not accept a
      * timestamp, and which will reset the wallet's nTimeFirstKey value to 1 if
      * the watch key did not previously have a timestamp associated with it.
      * Because this is an inherited virtual method, it is accessible despite
      * being marked private, but it is marked private anyway to encourage use
      * of the other AddWatchOnly which accepts a timestamp and sets
      * nTimeFirstKey more intelligently for more efficient rescans.
      */
     bool AddWatchOnly(const CScript &dest)
         EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore);
     bool AddWatchOnlyWithDB(WalletBatch &batch, const CScript &dest)
         EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore);
     bool AddWatchOnlyInMem(const CScript &dest);
     //! Adds a watch-only address to the store, and saves it to disk.
     bool AddWatchOnlyWithDB(WalletBatch &batch, const CScript &dest,
                             int64_t create_time)
         EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore);
 
     //! Adds a key to the store, and saves it to disk.
     bool AddKeyPubKeyWithDB(WalletBatch &batch, const CKey &key,
                             const CPubKey &pubkey)
         EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore);
 
     void AddKeypoolPubkeyWithDB(const CPubKey &pubkey, const bool internal,
                                 WalletBatch &batch);
 
     //! Adds a script to the store and saves it to disk
     bool AddCScriptWithDB(WalletBatch &batch, const CScript &script);
 
     /** Add a KeyOriginInfo to the wallet */
     bool AddKeyOriginWithDB(WalletBatch &batch, const CPubKey &pubkey,
                             const KeyOriginInfo &info);
 
     /* the HD chain data model (external chain counters) */
     CHDChain hdChain;
 
     /* HD derive new child key (on internal or external chain) */
     void DeriveNewChildKey(WalletBatch &batch, CKeyMetadata &metadata,
                            CKey &secret, bool internal = false)
         EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore);
 
     std::set<int64_t> setInternalKeyPool GUARDED_BY(cs_KeyStore);
     std::set<int64_t> setExternalKeyPool GUARDED_BY(cs_KeyStore);
     std::set<int64_t> set_pre_split_keypool GUARDED_BY(cs_KeyStore);
     int64_t m_max_keypool_index GUARDED_BY(cs_KeyStore) = 0;
     std::map<CKeyID, int64_t> m_pool_key_to_index;
     // Tracks keypool indexes to CKeyIDs of keys that have been taken out of the
     // keypool but may be returned to it
     std::map<int64_t, CKeyID> m_index_to_reserved_key;
 
     //! Fetches a key from the keypool
     bool GetKeyFromPool(CPubKey &key, const OutputType type,
                         bool internal = false);
 
     /**
      * Reserves a key from the keypool and sets nIndex to its index
      *
      * @param[out] nIndex the index of the key in keypool
      * @param[out] keypool the keypool the key was drawn from, which could be
      * the the pre-split pool if present, or the internal or external pool
      * @param fRequestedInternal true if the caller would like the key drawn
      *     from the internal keypool, false if external is preferred
      *
      * @return true if succeeded, false if failed due to empty keypool
      * @throws std::runtime_error if keypool read failed, key was invalid,
      *     was not found in the wallet, or was misclassified in the internal
      *     or external keypool
      */
     bool ReserveKeyFromKeyPool(int64_t &nIndex, CKeyPool &keypool,
                                bool fRequestedInternal);
 
 public:
     using ScriptPubKeyMan::ScriptPubKeyMan;
 
     bool GetNewDestination(const OutputType type, CTxDestination &dest,
                            std::string &error) override;
     isminetype IsMine(const CScript &script) const override;
 
     bool CheckDecryptionKey(const CKeyingMaterial &master_key,
                             bool accept_no_keys = false) override;
     bool Encrypt(const CKeyingMaterial &master_key,
                  WalletBatch *batch) override;
 
     bool GetReservedDestination(const OutputType type, bool internal,
                                 CTxDestination &address, int64_t &index,
                                 CKeyPool &keypool) override;
     void KeepDestination(int64_t index, const OutputType &type) override;
     void ReturnDestination(int64_t index, bool internal,
                            const CTxDestination &) override;
 
     bool TopUp(unsigned int size = 0) override;
 
     void MarkUnusedAddresses(const CScript &script) override;
 
     //! Upgrade stored CKeyMetadata objects to store key origin info as
     //! KeyOriginInfo
     void UpgradeKeyMetadata();
 
     bool IsHDEnabled() const override;
 
     bool SetupGeneration(bool force = false) override;
 
     bool Upgrade(int prev_version, bilingual_str &error) override;
 
     bool HavePrivateKeys() const override;
 
     void RewriteDB() override;
 
     int64_t GetOldestKeyPoolTime() const override;
     size_t KeypoolCountExternalKeys() const override;
     unsigned int GetKeyPoolSize() const override;
 
     int64_t GetTimeFirstKey() const override;
 
     const CKeyMetadata *GetMetadata(const CTxDestination &dest) const override;
 
     bool CanGetAddresses(bool internal = false) const override;
 
     std::unique_ptr<SigningProvider>
     GetSolvingProvider(const CScript &script) const override;
 
     bool CanProvide(const CScript &script, SignatureData &sigdata) override;
 
     bool
     SignTransaction(CMutableTransaction &tx,
                     const std::map<COutPoint, Coin> &coins, SigHashType sighash,
                     std::map<int, std::string> &input_errors) const override;
     SigningResult SignMessage(const std::string &message, const PKHash &pkhash,
                               std::string &str_sig) const override;
     TransactionError
     FillPSBT(PartiallySignedTransaction &psbt,
              SigHashType sighash_type = SigHashType().withForkId(),
              bool sign = true, bool bip32derivs = false) const override;
 
     uint256 GetID() const override;
 
     void SetType(OutputType type, bool internal) override;
 
     // Map from Key ID to key metadata.
     std::map<CKeyID, CKeyMetadata> mapKeyMetadata GUARDED_BY(cs_KeyStore);
 
     // Map from Script ID to key metadata (for watch-only keys).
     std::map<CScriptID, CKeyMetadata> m_script_metadata GUARDED_BY(cs_KeyStore);
 
     //! Adds a key to the store, and saves it to disk.
     bool AddKeyPubKey(const CKey &key, const CPubKey &pubkey) override;
     //! Adds a key to the store, without saving it to disk (used by LoadWallet)
     bool LoadKey(const CKey &key, const CPubKey &pubkey);
     //! Adds an encrypted key to the store, and saves it to disk.
     bool AddCryptedKey(const CPubKey &vchPubKey,
                        const std::vector<uint8_t> &vchCryptedSecret);
     //! Adds an encrypted key to the store, without saving it to disk (used by
     //! LoadWallet)
     bool LoadCryptedKey(const CPubKey &vchPubKey,
                         const std::vector<uint8_t> &vchCryptedSecret);
     void UpdateTimeFirstKey(int64_t nCreateTime)
         EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore);
     //! Adds a CScript to the store
     bool LoadCScript(const CScript &redeemScript);
     //! Load metadata (used by LoadWallet)
     void LoadKeyMetadata(const CKeyID &keyID, const CKeyMetadata &metadata);
     void LoadScriptMetadata(const CScriptID &script_id,
                             const CKeyMetadata &metadata);
     //! Generate a new key
     CPubKey GenerateNewKey(WalletBatch &batch, bool internal = false)
         EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore);
 
     /* Set the HD chain model (chain child index counters) */
     void SetHDChain(const CHDChain &chain, bool memonly);
     const CHDChain &GetHDChain() const { return hdChain; }
 
     //! Adds a watch-only address to the store, without saving it to disk (used
     //! by LoadWallet)
     bool LoadWatchOnly(const CScript &dest);
     //! Returns whether the watch-only script is in the wallet
     bool HaveWatchOnly(const CScript &dest) const;
     //! Returns whether there are any watch-only things in the wallet
     bool HaveWatchOnly() const;
     //! Remove a watch only script from the keystore
     bool RemoveWatchOnly(const CScript &dest);
     bool AddWatchOnly(const CScript &dest, int64_t nCreateTime)
         EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore);
 
     //! Fetches a pubkey from mapWatchKeys if it exists there
     bool GetWatchPubKey(const CKeyID &address, CPubKey &pubkey_out) const;
 
     /* SigningProvider overrides */
     bool HaveKey(const CKeyID &address) const override;
     bool GetKey(const CKeyID &address, CKey &keyOut) const override;
     bool GetPubKey(const CKeyID &address, CPubKey &vchPubKeyOut) const override;
     bool AddCScript(const CScript &redeemScript) override;
     bool GetKeyOrigin(const CKeyID &keyid, KeyOriginInfo &info) const override;
 
     //! Load a keypool entry
     void LoadKeyPool(int64_t nIndex, const CKeyPool &keypool);
     bool NewKeyPool();
     void MarkPreSplitKeys() EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore);
 
     bool ImportScripts(const std::set<CScript> scripts, int64_t timestamp)
         EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore);
     bool ImportPrivKeys(const std::map<CKeyID, CKey> &privkey_map,
                         const int64_t timestamp)
         EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore);
     bool 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)
         EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore);
     bool ImportScriptPubKeys(const std::set<CScript> &script_pub_keys,
                              const bool have_solving_data,
                              const int64_t timestamp)
         EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore);
 
     /* Returns true if the wallet can generate new keys */
     bool CanGenerateKeys() const;
 
     /* Generates a new HD seed (will not be activated) */
     CPubKey GenerateNewSeed();
 
     /* Derives a new HD seed (will not be activated) */
     CPubKey DeriveNewSeed(const CKey &key);
 
     /* Set the current HD seed (will reset the chain child index counters)
        Sets the seed's version based on the current wallet version (so the
        caller must ensure the current wallet version is correct before calling
        this function). */
     void SetHDSeed(const CPubKey &key);
 
     /**
      * Explicitly make the wallet learn the related scripts for outputs to the
      * given key. This is purely to make the wallet file compatible with older
      * software, as FillableSigningProvider automatically does this implicitly
      * for all keys now.
      */
     void LearnRelatedScripts(const CPubKey &key, OutputType);
 
     /**
      * Same as LearnRelatedScripts, but when the OutputType is not known (and
      * could be anything).
      */
     void LearnAllRelatedScripts(const CPubKey &key);
 
     /**
      * Marks all keys in the keypool up to and including reserve_key as used.
      */
     void MarkReserveKeysAsUsed(int64_t keypool_id)
         EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore);
     const std::map<CKeyID, int64_t> &GetAllReserveKeys() const {
         return m_pool_key_to_index;
     }
 
     std::set<CKeyID> GetKeys() const override;
 };
 
 /**
  * Wraps a LegacyScriptPubKeyMan so that it can be returned in a new unique_ptr.
  * Does not provide privkeys.
  */
 class LegacySigningProvider : public SigningProvider {
 private:
     const LegacyScriptPubKeyMan &m_spk_man;
 
 public:
     LegacySigningProvider(const LegacyScriptPubKeyMan &spk_man)
         : m_spk_man(spk_man) {}
 
     bool GetCScript(const CScriptID &scriptid, CScript &script) const override {
         return m_spk_man.GetCScript(scriptid, script);
     }
     bool HaveCScript(const CScriptID &scriptid) const override {
         return m_spk_man.HaveCScript(scriptid);
     }
     bool GetPubKey(const CKeyID &address, CPubKey &pubkey) const override {
         return m_spk_man.GetPubKey(address, pubkey);
     }
     bool GetKey(const CKeyID &address, CKey &key) const override {
         return false;
     }
     bool HaveKey(const CKeyID &address) const override { return false; }
     bool GetKeyOrigin(const CKeyID &keyid, KeyOriginInfo &info) const override {
         return m_spk_man.GetKeyOrigin(keyid, info);
     }
 };
 
 class DescriptorScriptPubKeyMan : public ScriptPubKeyMan {
 private:
     WalletDescriptor m_wallet_descriptor GUARDED_BY(cs_desc_man);
 
     // Map of scripts to descriptor range index
     using ScriptPubKeyMap = std::map<CScript, int32_t>;
     using CryptedKeyMap =
         std::map<CKeyID, std::pair<CPubKey, std::vector<uint8_t>>>;
     using KeyMap = std::map<CKeyID, CKey>;
 
     ScriptPubKeyMap m_map_script_pub_keys GUARDED_BY(cs_desc_man);
 
     OutputType m_address_type;
     bool m_internal;
 
     KeyMap m_map_keys GUARDED_BY(cs_desc_man);
     CryptedKeyMap m_map_crypted_keys GUARDED_BY(cs_desc_man);
 
     bool SetCrypted();
 
     //! keeps track of whether Unlock has run a thorough check before
     bool m_decryption_thoroughly_checked = false;
 
+    bool AddDescriptorKeyWithDB(WalletBatch &batch, const CKey &key,
+                                const CPubKey &pubkey);
+
 public:
     DescriptorScriptPubKeyMan(WalletStorage &storage,
                               WalletDescriptor &descriptor)
         : ScriptPubKeyMan(storage), m_wallet_descriptor(descriptor) {}
     DescriptorScriptPubKeyMan(WalletStorage &storage, OutputType address_type,
                               bool internal)
         : ScriptPubKeyMan(storage), m_address_type(address_type),
           m_internal(internal) {}
 
     mutable RecursiveMutex cs_desc_man;
 
     bool GetNewDestination(const OutputType type, CTxDestination &dest,
                            std::string &error) override;
     isminetype IsMine(const CScript &script) const override;
 
     bool CheckDecryptionKey(const CKeyingMaterial &master_key,
                             bool accept_no_keys = false) override;
     bool Encrypt(const CKeyingMaterial &master_key,
                  WalletBatch *batch) override;
 
     bool GetReservedDestination(const OutputType type, bool internal,
                                 CTxDestination &address, int64_t &index,
                                 CKeyPool &keypool) override;
     void ReturnDestination(int64_t index, bool internal,
                            const CTxDestination &addr) override;
 
     bool TopUp(unsigned int size = 0) override;
 
     void MarkUnusedAddresses(const CScript &script) override;
 
     bool IsHDEnabled() const override;
 
     bool HavePrivateKeys() const override;
 
     int64_t GetOldestKeyPoolTime() const override;
     size_t KeypoolCountExternalKeys() const override;
     unsigned int GetKeyPoolSize() const override;
 
     int64_t GetTimeFirstKey() const override;
 
     const CKeyMetadata *GetMetadata(const CTxDestination &dest) const override;
 
     bool CanGetAddresses(bool internal = false) const override;
 
     std::unique_ptr<SigningProvider>
     GetSolvingProvider(const CScript &script) const override;
 
     bool CanProvide(const CScript &script, SignatureData &sigdata) override;
 
     bool
     SignTransaction(CMutableTransaction &tx,
                     const std::map<COutPoint, Coin> &coins, SigHashType sighash,
                     std::map<int, std::string> &input_errors) const override;
     SigningResult SignMessage(const std::string &message, const PKHash &pkhash,
                               std::string &str_sig) const override;
     TransactionError
     FillPSBT(PartiallySignedTransaction &psbt,
              SigHashType sighash_type = SigHashType().withForkId(),
              bool sign = true, bool bip32derivs = false) const override;
 
     uint256 GetID() const override;
 
     void SetType(OutputType type, bool internal) override;
 
     void SetCache(const DescriptorCache &cache);
 
     bool AddKey(const CKeyID &key_id, const CKey &key);
     bool AddCryptedKey(const CKeyID &key_id, const CPubKey &pubkey,
                        const std::vector<uint8_t> &crypted_key);
 };
 
 #endif // BITCOIN_WALLET_SCRIPTPUBKEYMAN_H
diff --git a/src/wallet/walletdb.cpp b/src/wallet/walletdb.cpp
index 614468bb4..1a2fad8ba 100644
--- a/src/wallet/walletdb.cpp
+++ b/src/wallet/walletdb.cpp
@@ -1,1001 +1,1034 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <wallet/walletdb.h>
 
 #include <chainparams.h>
 #include <fs.h>
 #include <key_io.h>
 #include <protocol.h>
 #include <serialize.h>
 #include <sync.h>
 #include <util/system.h>
 #include <util/time.h>
 #include <wallet/wallet.h>
 
 #include <atomic>
 
 namespace DBKeys {
 const std::string ACENTRY{"acentry"};
 const std::string ACTIVEEXTERNALSPK{"activeexternalspk"};
 const std::string ACTIVEINTERNALSPK{"activeinternalspk"};
 const std::string BESTBLOCK_NOMERKLE{"bestblock_nomerkle"};
 const std::string BESTBLOCK{"bestblock"};
 const std::string CRYPTED_KEY{"ckey"};
 const std::string CSCRIPT{"cscript"};
 const std::string DEFAULTKEY{"defaultkey"};
 const std::string DESTDATA{"destdata"};
 const std::string FLAGS{"flags"};
 const std::string HDCHAIN{"hdchain"};
 const std::string KEYMETA{"keymeta"};
 const std::string KEY{"key"};
 const std::string MASTER_KEY{"mkey"};
 const std::string MINVERSION{"minversion"};
 const std::string NAME{"name"};
 const std::string OLD_KEY{"wkey"};
 const std::string ORDERPOSNEXT{"orderposnext"};
 const std::string POOL{"pool"};
 const std::string PURPOSE{"purpose"};
 const std::string SETTINGS{"settings"};
 const std::string TX{"tx"};
 const std::string VERSION{"version"};
 const std::string WALLETDESCRIPTOR{"walletdescriptor"};
 const std::string WALLETDESCRIPTORCACHE{"walletdescriptorcache"};
 const std::string WALLETDESCRIPTORCKEY{"walletdescriptorckey"};
 const std::string WALLETDESCRIPTORKEY{"walletdescriptorkey"};
 const std::string WATCHMETA{"watchmeta"};
 const std::string WATCHS{"watchs"};
 } // namespace DBKeys
 
 //
 // WalletBatch
 //
 
 bool WalletBatch::WriteName(const CTxDestination &address,
                             const std::string &strName) {
     if (!IsValidDestination(address)) {
         return false;
     }
     return WriteIC(
         std::make_pair(DBKeys::NAME, EncodeLegacyAddr(address, Params())),
         strName);
 }
 
 bool WalletBatch::EraseName(const CTxDestination &address) {
     // This should only be used for sending addresses, never for receiving
     // addresses, receiving addresses must always have an address book entry if
     // they're not change return.
     if (!IsValidDestination(address)) {
         return false;
     }
     return EraseIC(
         std::make_pair(DBKeys::NAME, EncodeLegacyAddr(address, Params())));
 }
 
 bool WalletBatch::WritePurpose(const CTxDestination &address,
                                const std::string &strPurpose) {
     if (!IsValidDestination(address)) {
         return false;
     }
     return WriteIC(
         std::make_pair(DBKeys::PURPOSE, EncodeLegacyAddr(address, Params())),
         strPurpose);
 }
 
 bool WalletBatch::ErasePurpose(const CTxDestination &address) {
     if (!IsValidDestination(address)) {
         return false;
     }
     return EraseIC(
         std::make_pair(DBKeys::PURPOSE, EncodeLegacyAddr(address, Params())));
 }
 
 bool WalletBatch::WriteTx(const CWalletTx &wtx) {
     return WriteIC(std::make_pair(DBKeys::TX, wtx.GetId()), wtx);
 }
 
 bool WalletBatch::EraseTx(uint256 hash) {
     return EraseIC(std::make_pair(DBKeys::TX, hash));
 }
 
 bool WalletBatch::WriteKeyMetadata(const CKeyMetadata &meta,
                                    const CPubKey &pubkey,
                                    const bool overwrite) {
     return WriteIC(std::make_pair(DBKeys::KEYMETA, pubkey), meta, overwrite);
 }
 
 bool WalletBatch::WriteKey(const CPubKey &vchPubKey, const CPrivKey &vchPrivKey,
                            const CKeyMetadata &keyMeta) {
     if (!WriteKeyMetadata(keyMeta, vchPubKey, false)) {
         return false;
     }
 
     // hash pubkey/privkey to accelerate wallet load
     std::vector<uint8_t> vchKey;
     vchKey.reserve(vchPubKey.size() + vchPrivKey.size());
     vchKey.insert(vchKey.end(), vchPubKey.begin(), vchPubKey.end());
     vchKey.insert(vchKey.end(), vchPrivKey.begin(), vchPrivKey.end());
 
     return WriteIC(
         std::make_pair(DBKeys::KEY, vchPubKey),
         std::make_pair(vchPrivKey, Hash(vchKey.begin(), vchKey.end())), false);
 }
 
 bool WalletBatch::WriteCryptedKey(const CPubKey &vchPubKey,
                                   const std::vector<uint8_t> &vchCryptedSecret,
                                   const CKeyMetadata &keyMeta) {
     if (!WriteKeyMetadata(keyMeta, vchPubKey, true)) {
         return false;
     }
 
     if (!WriteIC(std::make_pair(DBKeys::CRYPTED_KEY, vchPubKey),
                  vchCryptedSecret, false)) {
         return false;
     }
     EraseIC(std::make_pair(DBKeys::KEY, vchPubKey));
     return true;
 }
 
 bool WalletBatch::WriteMasterKey(unsigned int nID,
                                  const CMasterKey &kMasterKey) {
     return WriteIC(std::make_pair(DBKeys::MASTER_KEY, nID), kMasterKey, true);
 }
 
 bool WalletBatch::WriteCScript(const uint160 &hash,
                                const CScript &redeemScript) {
     return WriteIC(std::make_pair(DBKeys::CSCRIPT, hash), redeemScript, false);
 }
 
 bool WalletBatch::WriteWatchOnly(const CScript &dest,
                                  const CKeyMetadata &keyMeta) {
     if (!WriteIC(std::make_pair(DBKeys::WATCHMETA, dest), keyMeta)) {
         return false;
     }
     return WriteIC(std::make_pair(DBKeys::WATCHS, dest), '1');
 }
 
 bool WalletBatch::EraseWatchOnly(const CScript &dest) {
     if (!EraseIC(std::make_pair(DBKeys::WATCHMETA, dest))) {
         return false;
     }
     return EraseIC(std::make_pair(DBKeys::WATCHS, dest));
 }
 
 bool WalletBatch::WriteBestBlock(const CBlockLocator &locator) {
     // Write empty block locator so versions that require a merkle branch
     // automatically rescan
     WriteIC(DBKeys::BESTBLOCK, CBlockLocator());
     return WriteIC(DBKeys::BESTBLOCK_NOMERKLE, locator);
 }
 
 bool WalletBatch::ReadBestBlock(CBlockLocator &locator) {
     if (m_batch.Read(DBKeys::BESTBLOCK, locator) && !locator.vHave.empty()) {
         return true;
     }
     return m_batch.Read(DBKeys::BESTBLOCK_NOMERKLE, locator);
 }
 
 bool WalletBatch::WriteOrderPosNext(int64_t nOrderPosNext) {
     return WriteIC(DBKeys::ORDERPOSNEXT, nOrderPosNext);
 }
 
 bool WalletBatch::ReadPool(int64_t nPool, CKeyPool &keypool) {
     return m_batch.Read(std::make_pair(DBKeys::POOL, nPool), keypool);
 }
 
 bool WalletBatch::WritePool(int64_t nPool, const CKeyPool &keypool) {
     return WriteIC(std::make_pair(DBKeys::POOL, nPool), keypool);
 }
 
 bool WalletBatch::ErasePool(int64_t nPool) {
     return EraseIC(std::make_pair(DBKeys::POOL, nPool));
 }
 
 bool WalletBatch::WriteMinVersion(int nVersion) {
     return WriteIC(DBKeys::MINVERSION, nVersion);
 }
 
 bool WalletBatch::WriteActiveScriptPubKeyMan(uint8_t type, const uint256 &id,
                                              bool internal) {
     std::string key =
         internal ? DBKeys::ACTIVEINTERNALSPK : DBKeys::ACTIVEEXTERNALSPK;
     return WriteIC(make_pair(key, type), id);
 }
 
+bool WalletBatch::WriteDescriptorKey(const uint256 &desc_id,
+                                     const CPubKey &pubkey,
+                                     const CPrivKey &privkey) {
+    // hash pubkey/privkey to accelerate wallet load
+    std::vector<uint8_t> key;
+    key.reserve(pubkey.size() + privkey.size());
+    key.insert(key.end(), pubkey.begin(), pubkey.end());
+    key.insert(key.end(), privkey.begin(), privkey.end());
+
+    return WriteIC(std::make_pair(DBKeys::WALLETDESCRIPTORKEY,
+                                  std::make_pair(desc_id, pubkey)),
+                   std::make_pair(privkey, Hash(key.begin(), key.end())),
+                   false);
+}
+
+bool WalletBatch::WriteCryptedDescriptorKey(
+    const uint256 &desc_id, const CPubKey &pubkey,
+    const std::vector<uint8_t> &secret) {
+    if (!WriteIC(std::make_pair(DBKeys::WALLETDESCRIPTORCKEY,
+                                std::make_pair(desc_id, pubkey)),
+                 secret, false)) {
+        return false;
+    }
+    EraseIC(std::make_pair(DBKeys::WALLETDESCRIPTORKEY,
+                           std::make_pair(desc_id, pubkey)));
+    return true;
+}
+
+bool WalletBatch::WriteDescriptor(const uint256 &desc_id,
+                                  const WalletDescriptor &descriptor) {
+    return WriteIC(make_pair(DBKeys::WALLETDESCRIPTOR, desc_id), descriptor);
+}
+
 class CWalletScanState {
 public:
     unsigned int nKeys{0};
     unsigned int nCKeys{0};
     unsigned int nWatchKeys{0};
     unsigned int nKeyMeta{0};
     unsigned int m_unknown_records{0};
     bool fIsEncrypted{false};
     bool fAnyUnordered{false};
     std::vector<TxId> vWalletUpgrade;
     std::map<OutputType, uint256> m_active_external_spks;
     std::map<OutputType, uint256> m_active_internal_spks;
     std::map<uint256, DescriptorCache> m_descriptor_caches;
     std::map<std::pair<uint256, CKeyID>, CKey> m_descriptor_keys;
     std::map<std::pair<uint256, CKeyID>,
              std::pair<CPubKey, std::vector<uint8_t>>>
         m_descriptor_crypt_keys;
 
     CWalletScanState() {}
 };
 
 static bool ReadKeyValue(CWallet *pwallet, CDataStream &ssKey,
                          CDataStream &ssValue, CWalletScanState &wss,
                          std::string &strType, std::string &strErr)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     try {
         // Unserialize
         // Taking advantage of the fact that pair serialization is just the two
         // items serialized one after the other.
         ssKey >> strType;
         if (strType == DBKeys::NAME) {
             std::string strAddress;
             ssKey >> strAddress;
             std::string label;
             ssValue >> label;
             pwallet
                 ->m_address_book[DecodeDestination(strAddress,
                                                    pwallet->chainParams)]
                 .SetLabel(label);
         } else if (strType == DBKeys::PURPOSE) {
             std::string strAddress;
             ssKey >> strAddress;
             ssValue >> pwallet
                            ->m_address_book[DecodeDestination(
                                strAddress, pwallet->chainParams)]
                            .purpose;
         } else if (strType == DBKeys::TX) {
             TxId txid;
             ssKey >> txid;
             CWalletTx wtx(nullptr /* pwallet */, MakeTransactionRef());
             ssValue >> wtx;
             if (wtx.GetId() != txid) {
                 return false;
             }
 
             // Undo serialize changes in 31600
             if (31404 <= wtx.fTimeReceivedIsTxTime &&
                 wtx.fTimeReceivedIsTxTime <= 31703) {
                 if (!ssValue.empty()) {
                     char fTmp;
                     char fUnused;
                     std::string unused_string;
                     ssValue >> fTmp >> fUnused >> unused_string;
                     strErr = strprintf("LoadWallet() upgrading tx ver=%d %d %s",
                                        wtx.fTimeReceivedIsTxTime, fTmp,
                                        txid.ToString());
                     wtx.fTimeReceivedIsTxTime = fTmp;
                 } else {
                     strErr =
                         strprintf("LoadWallet() repairing tx ver=%d %s",
                                   wtx.fTimeReceivedIsTxTime, txid.ToString());
                     wtx.fTimeReceivedIsTxTime = 0;
                 }
                 wss.vWalletUpgrade.push_back(txid);
             }
 
             if (wtx.nOrderPos == -1) {
                 wss.fAnyUnordered = true;
             }
 
             pwallet->LoadToWallet(wtx);
         } else if (strType == DBKeys::WATCHS) {
             wss.nWatchKeys++;
             CScript script;
             ssKey >> script;
             char fYes;
             ssValue >> fYes;
             if (fYes == '1') {
                 pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadWatchOnly(
                     script);
             }
         } else if (strType == DBKeys::KEY) {
             CPubKey vchPubKey;
             ssKey >> vchPubKey;
             if (!vchPubKey.IsValid()) {
                 strErr = "Error reading wallet database: CPubKey corrupt";
                 return false;
             }
             CKey key;
             CPrivKey pkey;
             uint256 hash;
 
             wss.nKeys++;
             ssValue >> pkey;
 
             // Old wallets store keys as DBKeys::KEY [pubkey] => [privkey] ...
             // which was slow for wallets with lots of keys, because the public
             // key is re-derived from the private key using EC operations as a
             // checksum. Newer wallets store keys as DBKeys::KEY [pubkey] =>
             // [privkey][hash(pubkey,privkey)], which is much faster while
             // remaining backwards-compatible.
             try {
                 ssValue >> hash;
             } catch (...) {
             }
 
             bool fSkipCheck = false;
 
             if (!hash.IsNull()) {
                 // hash pubkey/privkey to accelerate wallet load
                 std::vector<uint8_t> vchKey;
                 vchKey.reserve(vchPubKey.size() + pkey.size());
                 vchKey.insert(vchKey.end(), vchPubKey.begin(), vchPubKey.end());
                 vchKey.insert(vchKey.end(), pkey.begin(), pkey.end());
 
                 if (Hash(vchKey.begin(), vchKey.end()) != hash) {
                     strErr = "Error reading wallet database: CPubKey/CPrivKey "
                              "corrupt";
                     return false;
                 }
 
                 fSkipCheck = true;
             }
 
             if (!key.Load(pkey, vchPubKey, fSkipCheck)) {
                 strErr = "Error reading wallet database: CPrivKey corrupt";
                 return false;
             }
             if (!pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadKey(
                     key, vchPubKey)) {
                 strErr = "Error reading wallet database: "
                          "LegacyScriptPubKeyMan::LoadKey failed";
                 return false;
             }
         } else if (strType == DBKeys::MASTER_KEY) {
             // Master encryption key is loaded into only the wallet and not any
             // of the ScriptPubKeyMans.
             unsigned int nID;
             ssKey >> nID;
             CMasterKey kMasterKey;
             ssValue >> kMasterKey;
             if (pwallet->mapMasterKeys.count(nID) != 0) {
                 strErr = strprintf(
                     "Error reading wallet database: duplicate CMasterKey id %u",
                     nID);
                 return false;
             }
             pwallet->mapMasterKeys[nID] = kMasterKey;
             if (pwallet->nMasterKeyMaxID < nID) {
                 pwallet->nMasterKeyMaxID = nID;
             }
         } else if (strType == DBKeys::CRYPTED_KEY) {
             CPubKey vchPubKey;
             ssKey >> vchPubKey;
             if (!vchPubKey.IsValid()) {
                 strErr = "Error reading wallet database: CPubKey corrupt";
                 return false;
             }
             std::vector<uint8_t> vchPrivKey;
             ssValue >> vchPrivKey;
             wss.nCKeys++;
 
             if (!pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadCryptedKey(
                     vchPubKey, vchPrivKey)) {
                 strErr = "Error reading wallet database: "
                          "LegacyScriptPubKeyMan::LoadCryptedKey failed";
                 return false;
             }
             wss.fIsEncrypted = true;
         } else if (strType == DBKeys::KEYMETA) {
             CPubKey vchPubKey;
             ssKey >> vchPubKey;
             CKeyMetadata keyMeta;
             ssValue >> keyMeta;
             wss.nKeyMeta++;
             pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadKeyMetadata(
                 vchPubKey.GetID(), keyMeta);
         } else if (strType == DBKeys::WATCHMETA) {
             CScript script;
             ssKey >> script;
             CKeyMetadata keyMeta;
             ssValue >> keyMeta;
             wss.nKeyMeta++;
             pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadScriptMetadata(
                 CScriptID(script), keyMeta);
         } else if (strType == DBKeys::DEFAULTKEY) {
             // We don't want or need the default key, but if there is one set,
             // we want to make sure that it is valid so that we can detect
             // corruption
             CPubKey vchPubKey;
             ssValue >> vchPubKey;
             if (!vchPubKey.IsValid()) {
                 strErr = "Error reading wallet database: Default Key corrupt";
                 return false;
             }
         } else if (strType == DBKeys::POOL) {
             int64_t nIndex;
             ssKey >> nIndex;
             CKeyPool keypool;
             ssValue >> keypool;
 
             pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadKeyPool(nIndex,
                                                                      keypool);
         } else if (strType == DBKeys::CSCRIPT) {
             uint160 hash;
             ssKey >> hash;
             CScript script;
             ssValue >> script;
             if (!pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadCScript(
                     script)) {
                 strErr = "Error reading wallet database: "
                          "LegacyScriptPubKeyMan::LoadCScript failed";
                 return false;
             }
         } else if (strType == DBKeys::ORDERPOSNEXT) {
             ssValue >> pwallet->nOrderPosNext;
         } else if (strType == DBKeys::DESTDATA) {
             std::string strAddress, strKey, strValue;
             ssKey >> strAddress;
             ssKey >> strKey;
             ssValue >> strValue;
             pwallet->LoadDestData(
                 DecodeDestination(strAddress, pwallet->chainParams), strKey,
                 strValue);
         } else if (strType == DBKeys::HDCHAIN) {
             CHDChain chain;
             ssValue >> chain;
             pwallet->GetOrCreateLegacyScriptPubKeyMan()->SetHDChain(chain,
                                                                     true);
         } else if (strType == DBKeys::FLAGS) {
             uint64_t flags;
             ssValue >> flags;
             if (!pwallet->SetWalletFlags(flags, true)) {
                 strErr = "Error reading wallet database: Unknown non-tolerable "
                          "wallet flags found";
                 return false;
             }
         } else if (strType == DBKeys::OLD_KEY) {
             strErr = "Found unsupported 'wkey' record, try loading with "
                      "version 0.20";
             return false;
         } else if (strType == DBKeys::ACTIVEEXTERNALSPK ||
                    strType == DBKeys::ACTIVEINTERNALSPK) {
             uint8_t type;
             ssKey >> type;
             uint256 id;
             ssValue >> id;
 
             bool internal = strType == DBKeys::ACTIVEINTERNALSPK;
             auto &spk_mans = internal ? wss.m_active_internal_spks
                                       : wss.m_active_external_spks;
             if (spk_mans.count(static_cast<OutputType>(type)) > 0) {
                 strErr =
                     "Multiple ScriptPubKeyMans specified for a single type";
                 return false;
             }
             spk_mans[static_cast<OutputType>(type)] = id;
         } else if (strType == DBKeys::WALLETDESCRIPTOR) {
             uint256 id;
             ssKey >> id;
             WalletDescriptor desc;
             ssValue >> desc;
             if (wss.m_descriptor_caches.count(id) == 0) {
                 wss.m_descriptor_caches[id] = DescriptorCache();
             }
             pwallet->LoadDescriptorScriptPubKeyMan(id, desc);
         } else if (strType == DBKeys::WALLETDESCRIPTORCACHE) {
             bool parent = true;
             uint256 desc_id;
             uint32_t key_exp_index;
             uint32_t der_index;
             ssKey >> desc_id;
             ssKey >> key_exp_index;
 
             // if the der_index exists, it's a derived xpub
             try {
                 ssKey >> der_index;
                 parent = false;
             } catch (...) {
             }
 
             std::vector<uint8_t> ser_xpub(BIP32_EXTKEY_SIZE);
             ssValue >> ser_xpub;
             CExtPubKey xpub;
             xpub.Decode(ser_xpub.data());
             if (wss.m_descriptor_caches.count(desc_id)) {
                 wss.m_descriptor_caches[desc_id] = DescriptorCache();
             }
             if (parent) {
                 wss.m_descriptor_caches[desc_id].CacheParentExtPubKey(
                     key_exp_index, xpub);
             } else {
                 wss.m_descriptor_caches[desc_id].CacheDerivedExtPubKey(
                     key_exp_index, der_index, xpub);
             }
         } else if (strType == DBKeys::WALLETDESCRIPTORKEY) {
             uint256 desc_id;
             CPubKey pubkey;
             ssKey >> desc_id;
             ssKey >> pubkey;
             if (!pubkey.IsValid()) {
                 strErr = "Error reading wallet database: CPubKey corrupt";
                 return false;
             }
             CKey key;
             CPrivKey pkey;
             uint256 hash;
 
             wss.nKeys++;
             ssValue >> pkey;
             ssValue >> hash;
 
             // hash pubkey/privkey to accelerate wallet load
             std::vector<uint8_t> to_hash;
             to_hash.reserve(pubkey.size() + pkey.size());
             to_hash.insert(to_hash.end(), pubkey.begin(), pubkey.end());
             to_hash.insert(to_hash.end(), pkey.begin(), pkey.end());
 
             if (Hash(to_hash.begin(), to_hash.end()) != hash) {
                 strErr =
                     "Error reading wallet database: CPubKey/CPrivKey corrupt";
                 return false;
             }
 
             if (!key.Load(pkey, pubkey, true)) {
                 strErr = "Error reading wallet database: CPrivKey corrupt";
                 return false;
             }
             wss.m_descriptor_keys.insert(
                 std::make_pair(std::make_pair(desc_id, pubkey.GetID()), key));
         } else if (strType == DBKeys::WALLETDESCRIPTORCKEY) {
             uint256 desc_id;
             CPubKey pubkey;
             ssKey >> desc_id;
             ssKey >> pubkey;
             if (!pubkey.IsValid()) {
                 strErr = "Error reading wallet database: CPubKey corrupt";
                 return false;
             }
             std::vector<uint8_t> privkey;
             ssValue >> privkey;
             wss.nCKeys++;
 
             wss.m_descriptor_crypt_keys.insert(
                 std::make_pair(std::make_pair(desc_id, pubkey.GetID()),
                                std::make_pair(pubkey, privkey)));
             wss.fIsEncrypted = true;
         } else if (strType != DBKeys::BESTBLOCK &&
                    strType != DBKeys::BESTBLOCK_NOMERKLE &&
                    strType != DBKeys::MINVERSION &&
                    strType != DBKeys::ACENTRY && strType != DBKeys::VERSION &&
                    strType != DBKeys::SETTINGS) {
             wss.m_unknown_records++;
         }
     } catch (const std::exception &e) {
         if (strErr.empty()) {
             strErr = e.what();
         }
         return false;
     } catch (...) {
         if (strErr.empty()) {
             strErr = "Caught unknown exception in ReadKeyValue";
         }
         return false;
     }
     return true;
 }
 
 bool WalletBatch::IsKeyType(const std::string &strType) {
     return (strType == DBKeys::KEY || strType == DBKeys::MASTER_KEY ||
             strType == DBKeys::CRYPTED_KEY);
 }
 
 DBErrors WalletBatch::LoadWallet(CWallet *pwallet) {
     CWalletScanState wss;
     bool fNoncriticalErrors = false;
     DBErrors result = DBErrors::LOAD_OK;
 
     LOCK(pwallet->cs_wallet);
     try {
         int nMinVersion = 0;
         if (m_batch.Read(DBKeys::MINVERSION, nMinVersion)) {
             if (nMinVersion > FEATURE_LATEST) {
                 return DBErrors::TOO_NEW;
             }
             pwallet->LoadMinVersion(nMinVersion);
         }
 
         // Get cursor
         Dbc *pcursor = m_batch.GetCursor();
         if (!pcursor) {
             pwallet->WalletLogPrintf("Error getting wallet database cursor\n");
             return DBErrors::CORRUPT;
         }
 
         while (true) {
             // Read next record
             CDataStream ssKey(SER_DISK, CLIENT_VERSION);
             CDataStream ssValue(SER_DISK, CLIENT_VERSION);
             int ret = m_batch.ReadAtCursor(pcursor, ssKey, ssValue);
             if (ret == DB_NOTFOUND) {
                 break;
             }
 
             if (ret != 0) {
                 pwallet->WalletLogPrintf(
                     "Error reading next record from wallet database\n");
                 return DBErrors::CORRUPT;
             }
 
             // Try to be tolerant of single corrupt records:
             std::string strType, strErr;
             if (!ReadKeyValue(pwallet, ssKey, ssValue, wss, strType, strErr)) {
                 // losing keys is considered a catastrophic error, anything else
                 // we assume the user can live with:
                 if (IsKeyType(strType) || strType == DBKeys::DEFAULTKEY) {
                     result = DBErrors::CORRUPT;
                 } else if (strType == DBKeys::FLAGS) {
                     // Reading the wallet flags can only fail if unknown flags
                     // are present.
                     result = DBErrors::TOO_NEW;
                 } else {
                     // Leave other errors alone, if we try to fix them we might
                     // make things worse. But do warn the user there is
                     // something wrong.
                     fNoncriticalErrors = true;
                     if (strType == DBKeys::TX) {
                         // Rescan if there is a bad transaction record:
                         gArgs.SoftSetBoolArg("-rescan", true);
                     }
                 }
             }
             if (!strErr.empty()) {
                 pwallet->WalletLogPrintf("%s\n", strErr);
             }
         }
         pcursor->close();
     } catch (const boost::thread_interrupted &) {
         throw;
     } catch (...) {
         result = DBErrors::CORRUPT;
     }
 
     // Set the active ScriptPubKeyMans
     for (auto spk_man_pair : wss.m_active_external_spks) {
         pwallet->SetActiveScriptPubKeyMan(
             spk_man_pair.second, spk_man_pair.first, /* internal */ false,
             /* memonly */ true);
     }
     for (auto spk_man_pair : wss.m_active_internal_spks) {
         pwallet->SetActiveScriptPubKeyMan(
             spk_man_pair.second, spk_man_pair.first, /* internal */ true,
             /* memonly */ true);
     }
 
     // Set the descriptor caches
     for (auto desc_cache_pair : wss.m_descriptor_caches) {
         auto spk_man = pwallet->GetScriptPubKeyMan(desc_cache_pair.first);
         assert(spk_man);
         ((DescriptorScriptPubKeyMan *)spk_man)
             ->SetCache(desc_cache_pair.second);
     }
 
     // Set the descriptor keys
     for (auto desc_key_pair : wss.m_descriptor_keys) {
         auto spk_man = pwallet->GetScriptPubKeyMan(desc_key_pair.first.first);
         ((DescriptorScriptPubKeyMan *)spk_man)
             ->AddKey(desc_key_pair.first.second, desc_key_pair.second);
     }
     for (auto desc_key_pair : wss.m_descriptor_crypt_keys) {
         auto spk_man = pwallet->GetScriptPubKeyMan(desc_key_pair.first.first);
         ((DescriptorScriptPubKeyMan *)spk_man)
             ->AddCryptedKey(desc_key_pair.first.second,
                             desc_key_pair.second.first,
                             desc_key_pair.second.second);
     }
 
     if (fNoncriticalErrors && result == DBErrors::LOAD_OK) {
         result = DBErrors::NONCRITICAL_ERROR;
     }
 
     // Any wallet corruption at all: skip any rewriting or upgrading, we don't
     // want to make it worse.
     if (result != DBErrors::LOAD_OK) {
         return result;
     }
 
     // Last client version to open this wallet, was previously the file version
     // number
     int last_client = CLIENT_VERSION;
     m_batch.Read(DBKeys::VERSION, last_client);
 
     int wallet_version = pwallet->GetVersion();
     pwallet->WalletLogPrintf("Wallet File Version = %d\n",
                              wallet_version > 0 ? wallet_version : last_client);
 
     pwallet->WalletLogPrintf("Keys: %u plaintext, %u encrypted, %u w/ "
                              "metadata, %u total. Unknown wallet records: %u\n",
                              wss.nKeys, wss.nCKeys, wss.nKeyMeta,
                              wss.nKeys + wss.nCKeys, wss.m_unknown_records);
 
     // nTimeFirstKey is only reliable if all keys have metadata
     if ((wss.nKeys + wss.nCKeys + wss.nWatchKeys) != wss.nKeyMeta) {
         auto spk_man = pwallet->GetOrCreateLegacyScriptPubKeyMan();
         if (spk_man) {
             LOCK(spk_man->cs_KeyStore);
             spk_man->UpdateTimeFirstKey(1);
         }
     }
 
     for (const TxId &txid : wss.vWalletUpgrade) {
         WriteTx(pwallet->mapWallet.at(txid));
     }
 
     // Rewrite encrypted wallets of versions 0.4.0 and 0.5.0rc:
     if (wss.fIsEncrypted && (last_client == 40000 || last_client == 50000)) {
         return DBErrors::NEED_REWRITE;
     }
 
     if (last_client < CLIENT_VERSION) {
         // Update
         m_batch.Write(DBKeys::VERSION, CLIENT_VERSION);
     }
 
     if (wss.fAnyUnordered) {
         result = pwallet->ReorderTransactions();
     }
 
     // Upgrade all of the wallet keymetadata to have the hd master key id
     // This operation is not atomic, but if it fails, updated entries are still
     // backwards compatible with older software
     try {
         pwallet->UpgradeKeyMetadata();
     } catch (...) {
         result = DBErrors::CORRUPT;
     }
 
     return result;
 }
 
 DBErrors WalletBatch::FindWalletTx(std::vector<TxId> &txIds,
                                    std::vector<CWalletTx> &vWtx) {
     DBErrors result = DBErrors::LOAD_OK;
 
     try {
         int nMinVersion = 0;
         if (m_batch.Read(DBKeys::MINVERSION, nMinVersion)) {
             if (nMinVersion > FEATURE_LATEST) {
                 return DBErrors::TOO_NEW;
             }
         }
 
         // Get cursor
         Dbc *pcursor = m_batch.GetCursor();
         if (!pcursor) {
             LogPrintf("Error getting wallet database cursor\n");
             return DBErrors::CORRUPT;
         }
 
         while (true) {
             // Read next record
             CDataStream ssKey(SER_DISK, CLIENT_VERSION);
             CDataStream ssValue(SER_DISK, CLIENT_VERSION);
             int ret = m_batch.ReadAtCursor(pcursor, ssKey, ssValue);
             if (ret == DB_NOTFOUND) {
                 break;
             }
 
             if (ret != 0) {
                 LogPrintf("Error reading next record from wallet database\n");
                 return DBErrors::CORRUPT;
             }
 
             std::string strType;
             ssKey >> strType;
             if (strType == DBKeys::TX) {
                 TxId txid;
                 ssKey >> txid;
 
                 CWalletTx wtx(nullptr /* pwallet */, MakeTransactionRef());
                 ssValue >> wtx;
 
                 txIds.push_back(txid);
                 vWtx.push_back(wtx);
             }
         }
         pcursor->close();
     } catch (const boost::thread_interrupted &) {
         throw;
     } catch (...) {
         result = DBErrors::CORRUPT;
     }
 
     return result;
 }
 
 DBErrors WalletBatch::ZapSelectTx(std::vector<TxId> &txIdsIn,
                                   std::vector<TxId> &txIdsOut) {
     // Build list of wallet TXs and hashes.
     std::vector<TxId> txIds;
     std::vector<CWalletTx> vWtx;
     DBErrors err = FindWalletTx(txIds, vWtx);
     if (err != DBErrors::LOAD_OK) {
         return err;
     }
 
     std::sort(txIds.begin(), txIds.end());
     std::sort(txIdsIn.begin(), txIdsIn.end());
 
     // Erase each matching wallet TX.
     bool delerror = false;
     std::vector<TxId>::iterator it = txIdsIn.begin();
     for (const TxId &txid : txIds) {
         while (it < txIdsIn.end() && (*it) < txid) {
             it++;
         }
         if (it == txIdsIn.end()) {
             break;
         }
 
         if ((*it) == txid) {
             if (!EraseTx(txid)) {
                 LogPrint(BCLog::WALLETDB,
                          "Transaction was found for deletion but returned "
                          "database error: %s\n",
                          txid.GetHex());
                 delerror = true;
             }
             txIdsOut.push_back(txid);
         }
     }
 
     if (delerror) {
         return DBErrors::CORRUPT;
     }
     return DBErrors::LOAD_OK;
 }
 
 DBErrors WalletBatch::ZapWalletTx(std::vector<CWalletTx> &vWtx) {
     // Build list of wallet TXs.
     std::vector<TxId> txIds;
     DBErrors err = FindWalletTx(txIds, vWtx);
     if (err != DBErrors::LOAD_OK) {
         return err;
     }
 
     // Erase each wallet TX.
     for (const TxId &txid : txIds) {
         if (!EraseTx(txid)) {
             return DBErrors::CORRUPT;
         }
     }
 
     return DBErrors::LOAD_OK;
 }
 
 void MaybeCompactWalletDB() {
     static std::atomic<bool> fOneThread;
     if (fOneThread.exchange(true)) {
         return;
     }
     if (!gArgs.GetBoolArg("-flushwallet", DEFAULT_FLUSHWALLET)) {
         return;
     }
 
     for (const std::shared_ptr<CWallet> &pwallet : GetWallets()) {
         WalletDatabase &dbh = pwallet->GetDBHandle();
 
         unsigned int nUpdateCounter = dbh.nUpdateCounter;
 
         if (dbh.nLastSeen != nUpdateCounter) {
             dbh.nLastSeen = nUpdateCounter;
             dbh.nLastWalletUpdate = GetTime();
         }
 
         if (dbh.nLastFlushed != nUpdateCounter &&
             GetTime() - dbh.nLastWalletUpdate >= 2) {
             if (BerkeleyBatch::PeriodicFlush(dbh)) {
                 dbh.nLastFlushed = nUpdateCounter;
             }
         }
     }
 
     fOneThread = false;
 }
 
 //
 // Try to (very carefully!) recover wallet file if there is a problem.
 //
 bool WalletBatch::Recover(const fs::path &wallet_path, void *callbackDataIn,
                           bool (*recoverKVcallback)(void *callbackData,
                                                     CDataStream ssKey,
                                                     CDataStream ssValue),
                           std::string &out_backup_filename) {
     return BerkeleyBatch::Recover(wallet_path, callbackDataIn,
                                   recoverKVcallback, out_backup_filename);
 }
 
 bool WalletBatch::Recover(const fs::path &wallet_path,
                           std::string &out_backup_filename) {
     // recover without a key filter callback
     // results in recovering all record types
     return WalletBatch::Recover(wallet_path, nullptr, nullptr,
                                 out_backup_filename);
 }
 
 bool WalletBatch::RecoverKeysOnlyFilter(void *callbackData, CDataStream ssKey,
                                         CDataStream ssValue) {
     CWallet *dummyWallet = reinterpret_cast<CWallet *>(callbackData);
     CWalletScanState dummyWss;
     std::string strType, strErr;
     bool fReadOK;
     {
         // Required in LoadKeyMetadata():
         LOCK(dummyWallet->cs_wallet);
         fReadOK = ReadKeyValue(dummyWallet, ssKey, ssValue, dummyWss, strType,
                                strErr);
     }
     if (!IsKeyType(strType) && strType != DBKeys::HDCHAIN) {
         return false;
     }
     if (!fReadOK) {
         LogPrintf("WARNING: WalletBatch::Recover skipping %s: %s\n", strType,
                   strErr);
         return false;
     }
 
     return true;
 }
 
 bool WalletBatch::VerifyEnvironment(const fs::path &wallet_path,
                                     bilingual_str &errorStr) {
     return BerkeleyBatch::VerifyEnvironment(wallet_path, errorStr);
 }
 
 bool WalletBatch::VerifyDatabaseFile(const fs::path &wallet_path,
                                      std::vector<bilingual_str> &warnings,
                                      bilingual_str &errorStr) {
     return BerkeleyBatch::VerifyDatabaseFile(wallet_path, warnings, errorStr,
                                              WalletBatch::Recover);
 }
 
 bool WalletBatch::WriteDestData(const CTxDestination &address,
                                 const std::string &key,
                                 const std::string &value) {
     if (!IsValidDestination(address)) {
         return false;
     }
     return WriteIC(
         std::make_pair(
             DBKeys::DESTDATA,
             std::make_pair(EncodeLegacyAddr(address, Params()), key)),
         value);
 }
 
 bool WalletBatch::EraseDestData(const CTxDestination &address,
                                 const std::string &key) {
     if (!IsValidDestination(address)) {
         return false;
     }
     return EraseIC(std::make_pair(
         DBKeys::DESTDATA,
         std::make_pair(EncodeLegacyAddr(address, Params()), key)));
 }
 
 bool WalletBatch::WriteHDChain(const CHDChain &chain) {
     return WriteIC(DBKeys::HDCHAIN, chain);
 }
 
 bool WalletBatch::WriteWalletFlags(const uint64_t flags) {
     return WriteIC(DBKeys::FLAGS, flags);
 }
 
 bool WalletBatch::TxnBegin() {
     return m_batch.TxnBegin();
 }
 
 bool WalletBatch::TxnCommit() {
     return m_batch.TxnCommit();
 }
 
 bool WalletBatch::TxnAbort() {
     return m_batch.TxnAbort();
 }
diff --git a/src/wallet/walletdb.h b/src/wallet/walletdb.h
index 4abb87806..2ed185f36 100644
--- a/src/wallet/walletdb.h
+++ b/src/wallet/walletdb.h
@@ -1,278 +1,287 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_WALLET_WALLETDB_H
 #define BITCOIN_WALLET_WALLETDB_H
 
 #include <amount.h>
 #include <key.h>
 #include <script/sign.h>
 #include <script/standard.h> // for CTxDestination
 #include <wallet/db.h>
+#include <wallet/walletutil.h>
 
 #include <cstdint>
 #include <string>
 #include <vector>
 
 /**
  * Overview of wallet database classes:
  *
  * - WalletBatch is an abstract modifier object for the wallet database, and
  * encapsulates a database batch update as well as methods to act on the
  * database. It should be agnostic to the database implementation.
  *
  * The following classes are implementation specific:
  * - BerkeleyEnvironment is an environment in which the database exists.
  * - BerkeleyDatabase represents a wallet database.
  * - BerkeleyBatch is a low-level database batch update.
  */
 
 static const bool DEFAULT_FLUSHWALLET = true;
 
 struct CBlockLocator;
 class CKeyPool;
 class CMasterKey;
 class CScript;
 class CWallet;
 class CWalletTx;
 class uint160;
 class uint256;
 
 /** Backend-agnostic database type. */
 using WalletDatabase = BerkeleyDatabase;
 
 /** Error statuses for the wallet database */
 enum class DBErrors {
     LOAD_OK,
     CORRUPT,
     NONCRITICAL_ERROR,
     TOO_NEW,
     LOAD_FAIL,
     NEED_REWRITE
 };
 
 /* simple HD chain data model */
 class CHDChain {
 public:
     uint32_t nExternalChainCounter;
     uint32_t nInternalChainCounter;
     //! seed hash160
     CKeyID seed_id;
 
     static const int VERSION_HD_BASE = 1;
     static const int VERSION_HD_CHAIN_SPLIT = 2;
     static const int CURRENT_VERSION = VERSION_HD_CHAIN_SPLIT;
     int nVersion;
 
     CHDChain() { SetNull(); }
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(this->nVersion);
         READWRITE(nExternalChainCounter);
         READWRITE(seed_id);
         if (this->nVersion >= VERSION_HD_CHAIN_SPLIT) {
             READWRITE(nInternalChainCounter);
         }
     }
 
     void SetNull() {
         nVersion = CHDChain::CURRENT_VERSION;
         nExternalChainCounter = 0;
         nInternalChainCounter = 0;
         seed_id.SetNull();
     }
 };
 
 class CKeyMetadata {
 public:
     static const int VERSION_BASIC = 1;
     static const int VERSION_WITH_HDDATA = 10;
     static const int VERSION_WITH_KEY_ORIGIN = 12;
     static const int CURRENT_VERSION = VERSION_WITH_KEY_ORIGIN;
     int nVersion;
     // 0 means unknown.
     int64_t nCreateTime;
     // optional HD/bip32 keypath. Still used to determine whether a key is a
     // seed. Also kept for backwards compatibility
     std::string hdKeypath;
     // Id of the HD seed used to derive this key.
     CKeyID hd_seed_id;
     // Key origin info with path and fingerprint
     KeyOriginInfo key_origin;
     //< Whether the key_origin is useful
     bool has_key_origin = false;
 
     CKeyMetadata() { SetNull(); }
     explicit CKeyMetadata(int64_t nCreateTime_) {
         SetNull();
         nCreateTime = nCreateTime_;
     }
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(this->nVersion);
         READWRITE(nCreateTime);
         if (this->nVersion >= VERSION_WITH_HDDATA) {
             READWRITE(hdKeypath);
             READWRITE(hd_seed_id);
         }
         if (this->nVersion >= VERSION_WITH_KEY_ORIGIN) {
             READWRITE(key_origin);
             READWRITE(has_key_origin);
         }
     }
 
     void SetNull() {
         nVersion = CKeyMetadata::CURRENT_VERSION;
         nCreateTime = 0;
         hdKeypath.clear();
         hd_seed_id.SetNull();
         key_origin.clear();
         has_key_origin = false;
     }
 };
 
 /**
  * Access to the wallet database.
  * Opens the database and provides read and write access to it. Each read and
  * write is its own transaction. Multiple operation transactions can be started
  * using TxnBegin() and committed using TxnCommit() Otherwise the transaction
  * will be committed when the object goes out of scope. Optionally (on by
  * default) it will flush to disk on close. Every 1000 writes will automatically
  * trigger a flush to disk.
  */
 class WalletBatch {
 private:
     template <typename K, typename T>
     bool WriteIC(const K &key, const T &value, bool fOverwrite = true) {
         if (!m_batch.Write(key, value, fOverwrite)) {
             return false;
         }
         m_database.IncrementUpdateCounter();
         if (m_database.nUpdateCounter % 1000 == 0) {
             m_batch.Flush();
         }
         return true;
     }
 
     template <typename K> bool EraseIC(const K &key) {
         if (!m_batch.Erase(key)) {
             return false;
         }
         m_database.IncrementUpdateCounter();
         if (m_database.nUpdateCounter % 1000 == 0) {
             m_batch.Flush();
         }
         return true;
     }
 
 public:
     explicit WalletBatch(WalletDatabase &database, const char *pszMode = "r+",
                          bool _fFlushOnClose = true)
         : m_batch(database, pszMode, _fFlushOnClose), m_database(database) {}
     WalletBatch(const WalletBatch &) = delete;
     WalletBatch &operator=(const WalletBatch &) = delete;
 
     bool WriteName(const CTxDestination &address, const std::string &strName);
     bool EraseName(const CTxDestination &address);
 
     bool WritePurpose(const CTxDestination &address,
                       const std::string &purpose);
     bool ErasePurpose(const CTxDestination &address);
 
     bool WriteTx(const CWalletTx &wtx);
     bool EraseTx(uint256 hash);
 
     bool WriteKeyMetadata(const CKeyMetadata &meta, const CPubKey &pubkey,
                           const bool overwrite);
     bool WriteKey(const CPubKey &vchPubKey, const CPrivKey &vchPrivKey,
                   const CKeyMetadata &keyMeta);
     bool WriteCryptedKey(const CPubKey &vchPubKey,
                          const std::vector<uint8_t> &vchCryptedSecret,
                          const CKeyMetadata &keyMeta);
     bool WriteMasterKey(unsigned int nID, const CMasterKey &kMasterKey);
 
     bool WriteCScript(const uint160 &hash, const CScript &redeemScript);
 
     bool WriteWatchOnly(const CScript &script, const CKeyMetadata &keymeta);
     bool EraseWatchOnly(const CScript &script);
 
     bool WriteBestBlock(const CBlockLocator &locator);
     bool ReadBestBlock(CBlockLocator &locator);
 
     bool WriteOrderPosNext(int64_t nOrderPosNext);
 
     bool ReadPool(int64_t nPool, CKeyPool &keypool);
     bool WritePool(int64_t nPool, const CKeyPool &keypool);
     bool ErasePool(int64_t nPool);
 
     bool WriteMinVersion(int nVersion);
 
+    bool WriteDescriptorKey(const uint256 &desc_id, const CPubKey &pubkey,
+                            const CPrivKey &privkey);
+    bool WriteCryptedDescriptorKey(const uint256 &desc_id,
+                                   const CPubKey &pubkey,
+                                   const std::vector<uint8_t> &secret);
+    bool WriteDescriptor(const uint256 &desc_id,
+                         const WalletDescriptor &descriptor);
+
     /// Write destination data key,value tuple to database.
     bool WriteDestData(const CTxDestination &address, const std::string &key,
                        const std::string &value);
     /// Erase destination data tuple from wallet database.
     bool EraseDestData(const CTxDestination &address, const std::string &key);
 
     bool WriteActiveScriptPubKeyMan(uint8_t type, const uint256 &id,
                                     bool internal);
 
     DBErrors LoadWallet(CWallet *pwallet);
     DBErrors FindWalletTx(std::vector<TxId> &txIds,
                           std::vector<CWalletTx> &vWtx);
     DBErrors ZapWalletTx(std::vector<CWalletTx> &vWtx);
     DBErrors ZapSelectTx(std::vector<TxId> &txIdsIn,
                          std::vector<TxId> &txIdsOut);
     /* Try to (very carefully!) recover wallet database (with a possible key
      * type filter) */
     static bool Recover(const fs::path &wallet_path, void *callbackDataIn,
                         bool (*recoverKVcallback)(void *callbackData,
                                                   CDataStream ssKey,
                                                   CDataStream ssValue),
                         std::string &out_backup_filename);
     /* Recover convenience-function to bypass the key filter callback, called
      * when verify fails, recovers everything */
     static bool Recover(const fs::path &wallet_path,
                         std::string &out_backup_filename);
     /* Recover filter (used as callback), will only let keys (cryptographical
      * keys) as KV/key-type pass through */
     static bool RecoverKeysOnlyFilter(void *callbackData, CDataStream ssKey,
                                       CDataStream ssValue);
     /* Function to determine if a certain KV/key-type is a key (cryptographical
      * key) type */
     static bool IsKeyType(const std::string &strType);
     /* verifies the database environment */
     static bool VerifyEnvironment(const fs::path &wallet_path,
                                   bilingual_str &errorStr);
     /* verifies the database file */
     static bool VerifyDatabaseFile(const fs::path &wallet_path,
                                    std::vector<bilingual_str> &warnings,
                                    bilingual_str &errorStr);
 
     //! write the hdchain model (external chain child index counter)
     bool WriteHDChain(const CHDChain &chain);
 
     bool WriteWalletFlags(const uint64_t flags);
     //! Begin a new transaction
     bool TxnBegin();
     //! Commit current transaction
     bool TxnCommit();
     //! Abort current transaction
     bool TxnAbort();
 
 private:
     BerkeleyBatch m_batch;
     WalletDatabase &m_database;
 };
 
 //! Compacts BDB state so that wallet.dat is self-contained (if there are
 //! changes)
 void MaybeCompactWalletDB();
 
 #endif // BITCOIN_WALLET_WALLETDB_H