diff --git a/src/wallet/scriptpubkeyman.cpp b/src/wallet/scriptpubkeyman.cpp
index cd3ea2819..a5e73b9ce 100644
--- a/src/wallet/scriptpubkeyman.cpp
+++ b/src/wallet/scriptpubkeyman.cpp
@@ -1,1519 +1,1625 @@
 // 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 {
+    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) {}
+
+bool DescriptorScriptPubKeyMan::IsHDEnabled() const {
+    return false;
+}
+
+bool DescriptorScriptPubKeyMan::CanGetAddresses(bool internal) const {
+    return false;
+}
+
+bool DescriptorScriptPubKeyMan::HavePrivateKeys() const {
+    return false;
+}
+
+int64_t DescriptorScriptPubKeyMan::GetOldestKeyPoolTime() const {
+    return GetTime();
+}
+
+size_t DescriptorScriptPubKeyMan::KeypoolCountExternalKeys() const {
+    return 0;
+}
+
+unsigned int DescriptorScriptPubKeyMan::GetKeyPoolSize() const {
+    return 0;
+}
+
+int64_t DescriptorScriptPubKeyMan::GetTimeFirstKey() const {
+    return 0;
+}
+
+std::unique_ptr<SigningProvider>
+DescriptorScriptPubKeyMan::GetSolvingProvider(const CScript &script) const {
+    return nullptr;
+}
+
+bool DescriptorScriptPubKeyMan::CanProvide(const CScript &script,
+                                           SignatureData &sigdata) {
+    return false;
+}
+
+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 {
+    return uint256();
+}
+
+void DescriptorScriptPubKeyMan::SetType(OutputType type, bool internal) {}
diff --git a/src/wallet/scriptpubkeyman.h b/src/wallet/scriptpubkeyman.h
index 25e7cac9a..ab6ca58a7 100644
--- a/src/wallet/scriptpubkeyman.h
+++ b/src/wallet/scriptpubkeyman.h
@@ -1,619 +1,678 @@
 // 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 {
+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 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;
+};
+
 #endif // BITCOIN_WALLET_SCRIPTPUBKEYMAN_H