scriptpubkeyman.cpp

Go to the documentation of this file.

// Copyright (c) 2019 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#include <chainparams.h>
#include <common/args.h>
#include <config.h>
#include <key_io.h>
#include <logging.h>
#include <node/types.h>
#include <outputtype.h>
#include <script/descriptor.h>
#include <script/script.h>
#include <script/sign.h>
#include <util/bip32.h>
#include <util/strencodings.h>
#include <util/string.h>
#include <util/translation.h>
#include <wallet/scriptpubkeyman.h>
 
using common::PSBTError;
using util::ToString;
 
const uint32_t BIP32_HARDENED_KEY_LIMIT = 0x80000000;
 
util::Result<CTxDestination>
LegacyScriptPubKeyMan::GetNewDestination(const OutputType type) {
    LOCK(cs_KeyStore);
 
    // Generate a new key that is added to wallet
    CPubKey new_key;
    if (!GetKeyFromPool(new_key, type)) {
        return util::Error{
            _("Error: Keypool ran out, please call keypoolrefill first")};
    }
    LearnRelatedScripts(new_key, type);
    return GetDestinationForKey(new_key, type);
}
 
typedef std::vector<uint8_t> valtype;
 
namespace {
 
enum class IsMineSigVersion {
    TOP = 0,  
    P2SH = 1, 
};
 
enum class IsMineResult {
    NO = 0,         
    WATCH_ONLY = 1, 
    SPENDABLE = 2,  
    INVALID = 3,    
};
 
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,
                         bool recurse_scripthash = true) {
    IsMineResult ret = IsMineResult::NO;
 
    std::vector<valtype> vSolutions;
    TxoutType whichType = Solver(scriptPubKey, vSolutions);
 
    CKeyID keyID;
    switch (whichType) {
        case TxoutType::NONSTANDARD:
        case TxoutType::NULL_DATA:
            break;
        case TxoutType::PUBKEY:
            keyID = CPubKey(vSolutions[0]).GetID();
            if (keystore.HaveKey(keyID)) {
                ret = std::max(ret, IsMineResult::SPENDABLE);
            }
            break;
        case TxoutType::PUBKEYHASH:
            keyID = CKeyID(uint160(vSolutions[0]));
            if (keystore.HaveKey(keyID)) {
                ret = std::max(ret, IsMineResult::SPENDABLE);
            }
            break;
        case TxoutType::SCRIPTHASH: {
            if (sigversion != IsMineSigVersion::TOP) {
                // P2SH inside P2SH is invalid.
                return IsMineResult::INVALID;
            }
            CScriptID scriptID = CScriptID(uint160(vSolutions[0]));
            CScript subscript;
            if (keystore.GetCScript(scriptID, subscript)) {
                ret = std::max(ret, recurse_scripthash
                                        ? IsMineInner(keystore, subscript,
                                                      IsMineSigVersion::P2SH)
                                        : IsMineResult::SPENDABLE);
            }
            break;
        }
        case TxoutType::MULTISIG: {
            // Never treat bare multisig outputs as ours (they can still be made
            // watchonly-though)
            if (sigversion == IsMineSigVersion::TOP) {
                break;
            }
 
            // Only consider transactions "mine" if we own ALL the keys
            // involved. Multi-signature transactions that are partially owned
            // (somebody else has a key that can spend them) enable
            // spend-out-from-under-you attacks, especially in shared-wallet
            // situations.
            std::vector<valtype> keys(vSolutions.begin() + 1,
                                      vSolutions.begin() + vSolutions.size() -
                                          1);
            if (HaveKeys(keys, keystore)) {
                ret = std::max(ret, IsMineResult::SPENDABLE);
            }
            break;
        }
    }
 
    if (ret == IsMineResult::NO && keystore.HaveWatchOnly(scriptPubKey)) {
        ret = std::max(ret, IsMineResult::WATCH_ONLY);
    }
    return ret;
}
 
} // namespace
 
isminetype LegacyScriptPubKeyMan::IsMine(const CScript &script) const {
    switch (IsMineInner(*this, script, IsMineSigVersion::TOP)) {
        case IsMineResult::INVALID:
        case IsMineResult::NO:
            return ISMINE_NO;
        case IsMineResult::WATCH_ONLY:
            return ISMINE_WATCH_ONLY;
        case IsMineResult::SPENDABLE:
            return ISMINE_SPENDABLE;
    }
    assert(false);
}
 
bool LegacyScriptPubKeyMan::CheckDecryptionKey(
    const CKeyingMaterial &master_key, bool accept_no_keys) {
    {
        LOCK(cs_KeyStore);
        assert(mapKeys.empty());
 
        // Always pass when there are no encrypted keys
        bool keyPass = mapCryptedKeys.empty();
        bool keyFail = false;
        CryptedKeyMap::const_iterator mi = mapCryptedKeys.begin();
        WalletBatch batch(m_storage.GetDatabase());
        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;
            } else {
                // Rewrite these encrypted keys with checksums
                batch.WriteCryptedKey(vchPubKey, vchCryptedSecret,
                                      mapKeyMetadata[vchPubKey.GetID()]);
            }
        }
        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;
}
 
bool LegacyScriptPubKeyMan::TopUpInactiveHDChain(const CKeyID seed_id,
                                                 int64_t index, bool internal) {
    LOCK(cs_KeyStore);
 
    if (m_storage.IsLocked()) {
        return false;
    }
 
    auto it = m_inactive_hd_chains.find(seed_id);
    if (it == m_inactive_hd_chains.end()) {
        return false;
    }
 
    CHDChain &chain = it->second;
 
    // Top up key pool
    int64_t target_size =
        std::max(gArgs.GetIntArg("-keypool", DEFAULT_KEYPOOL_SIZE), (int64_t)1);
 
    // "size" of the keypools. Not really the size, actually the difference
    // between index and the chain counter Since chain counter is 1 based and
    // index is 0 based, one of them needs to be offset by 1.
    int64_t kp_size =
        (internal ? chain.nInternalChainCounter : chain.nExternalChainCounter) -
        (index + 1);
 
    // make sure the keypool fits the user-selected target (-keypool)
    int64_t missing = std::max(target_size - kp_size, (int64_t)0);
 
    if (missing > 0) {
        WalletBatch batch(m_storage.GetDatabase());
        for (int64_t i = missing; i > 0; --i) {
            GenerateNewKey(batch, chain, internal);
        }
        if (internal) {
            WalletLogPrintf("inactive seed with id %s added %d internal keys\n",
                            HexStr(seed_id), missing);
        } else {
            WalletLogPrintf("inactive seed with id %s added %d keys\n",
                            HexStr(seed_id), missing);
        }
    }
    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 "
                            "keys up to this key as used\n",
                            __func__);
            MarkReserveKeysAsUsed(mi->second);
 
            if (!TopUp()) {
                WalletLogPrintf(
                    "%s: Topping up keypool failed (locked wallet)\n",
                    __func__);
            }
        }
 
        // Find the key's metadata and check if it's seed id (if it has one) is
        // inactive, i.e. it is not the current m_hd_chain seed id. If so, TopUp
        // the inactive hd chain
        auto it = mapKeyMetadata.find(keyid);
        if (it != mapKeyMetadata.end()) {
            CKeyMetadata meta = it->second;
            if (!meta.hd_seed_id.IsNull() &&
                meta.hd_seed_id != m_hd_chain.seed_id) {
                bool internal =
                    (meta.key_origin.path[1] & ~BIP32_HARDENED_KEY_LIMIT) != 0;
                int64_t index =
                    meta.key_origin.path[2] & ~BIP32_HARDENED_KEY_LIMIT;
 
                if (!TopUpInactiveHDChain(meta.hd_seed_id, index, internal)) {
                    WalletLogPrintf("%s: Adding inactive seed keys failed\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);
            // 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 !m_hd_chain.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)) {
        WalletLogPrintf("Upgrading wallet to use HD chain split\n");
        m_storage.SetMinVersion(FEATURE_PRE_SPLIT_KEYPOOL);
        split_upgrade = FEATURE_HD_SPLIT > prev_version;
    }
    // Mark all keys currently in the keypool as pre-split
    if (split_upgrade) {
        MarkPreSplitKeys();
    }
    // Regenerate the keypool if upgraded to HD
    if (hd_upgrade) {
        if (!TopUp()) {
            error = _("Unable to generate keys");
            return false;
        }
    }
    return true;
}
 
bool LegacyScriptPubKeyMan::HavePrivateKeys() const {
    LOCK(cs_KeyStore);
    return !mapKeys.empty() || !mapCryptedKeys.empty();
}
 
void LegacyScriptPubKeyMan::RewriteDB() {
    LOCK(cs_KeyStore);
    setInternalKeyPool.clear();
    setExternalKeyPool.clear();
    m_pool_key_to_index.clear();
    // Note: can't top-up keypool here, because wallet is locked.
    // User will be prompted to unlock wallet the next operation
    // that requires a new key.
}
 
static int64_t GetOldestKeyTimeInPool(const std::set<int64_t> &setKeyPool,
                                      WalletBatch &batch) {
    if (setKeyPool.empty()) {
        return GetTime();
    }
 
    CKeyPool keypool;
    int64_t nIndex = *(setKeyPool.begin());
    if (!batch.ReadPool(nIndex, keypool)) {
        throw std::runtime_error(std::string(__func__) +
                                 ": read oldest key in keypool failed");
    }
 
    assert(keypool.vchPubKey.IsValid());
    return keypool.nTime;
}
 
int64_t LegacyScriptPubKeyMan::GetOldestKeyPoolTime() const {
    LOCK(cs_KeyStore);
 
    WalletBatch batch(m_storage.GetDatabase());
 
    // load oldest key from keypool, get time and return
    int64_t oldestKey = GetOldestKeyTimeInPool(setExternalKeyPool, batch);
    if (IsHDEnabled() && m_storage.CanSupportFeature(FEATURE_HD_SPLIT)) {
        oldestKey = std::max(GetOldestKeyTimeInPool(setInternalKeyPool, batch),
                             oldestKey);
        if (!set_pre_split_keypool.empty()) {
            oldestKey =
                std::max(GetOldestKeyTimeInPool(set_pre_split_keypool, batch),
                         oldestKey);
        }
    }
 
    return oldestKey;
}
 
size_t LegacyScriptPubKeyMan::KeypoolCountExternalKeys() const {
    LOCK(cs_KeyStore);
    return setExternalKeyPool.size() + set_pre_split_keypool.size();
}
 
unsigned int LegacyScriptPubKeyMan::GetKeyPoolSize() const {
    LOCK(cs_KeyStore);
    return setInternalKeyPool.size() + setExternalKeyPool.size() +
           set_pre_split_keypool.size();
}
 
int64_t LegacyScriptPubKeyMan::GetTimeFirstKey() const {
    LOCK(cs_KeyStore);
    return nTimeFirstKey;
}
 
std::unique_ptr<SigningProvider>
LegacyScriptPubKeyMan::GetSolvingProvider(const CScript &script) const {
    return std::make_unique<LegacySigningProvider>(*this);
}
 
bool LegacyScriptPubKeyMan::CanProvide(const CScript &script,
                                       SignatureData &sigdata) {
    IsMineResult ismine = IsMineInner(*this, script, IsMineSigVersion::TOP,
                                      /* recurse_scripthash= */ false);
    if (ismine == IsMineResult::SPENDABLE ||
        ismine == IsMineResult::WATCH_ONLY) {
        // If ismine, it means we recognize keys or script ids in the script, or
        // are watching the script itself, and we can at least provide metadata
        // or solving information, even if not able to sign fully.
        return true;
    }
    // If, given the stuff in sigdata, we could make a valid sigature, then
    // we can provide for this script
    ProduceSignature(*this, DUMMY_SIGNATURE_CREATOR, script, sigdata);
    if (!sigdata.signatures.empty()) {
        // If we could make signatures, make sure we have a private key to
        // actually make a signature
        bool has_privkeys = false;
        for (const auto &key_sig_pair : sigdata.signatures) {
            has_privkeys |= HaveKey(key_sig_pair.first);
        }
        return has_privkeys;
    }
    return false;
}
 
bool LegacyScriptPubKeyMan::SignTransaction(
    CMutableTransaction &tx, const std::map<COutPoint, Coin> &coins,
    SigHashType sighash, std::map<int, std::string> &input_errors) const {
    return ::SignTransaction(tx, this, coins, sighash, input_errors);
}
 
SigningResult LegacyScriptPubKeyMan::SignMessage(const std::string &message,
                                                 const PKHash &pkhash,
                                                 std::string &str_sig) const {
    CKey key;
    if (!GetKey(ToKeyID(pkhash), key)) {
        return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
    }
 
    if (MessageSign(key, message, str_sig)) {
        return SigningResult::OK;
    }
    return SigningResult::SIGNING_FAILED;
}
 
std::optional<PSBTError>
LegacyScriptPubKeyMan::FillPSBT(PartiallySignedTransaction &psbtx,
                                SigHashType sighash_type, bool sign,
                                bool bip32derivs, bool finalize) const {
    for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
        PSBTInput &input = psbtx.inputs.at(i);
 
        if (PSBTInputSigned(input)) {
            continue;
        }
 
        // Get the Sighash type
        if (sign && input.sighash_type != std::nullopt &&
            *input.sighash_type != sighash_type) {
            return PSBTError::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, /*out_sigdata=*/nullptr,
                      /*use_dummy=*/false, finalize);
    }
 
    // 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 {};
}
 
std::unique_ptr<CKeyMetadata>
LegacyScriptPubKeyMan::GetMetadata(const CTxDestination &dest) const {
    LOCK(cs_KeyStore);
 
    CKeyID key_id = GetKeyForDestination(*this, dest);
    if (!key_id.IsNull()) {
        auto it = mapKeyMetadata.find(key_id);
        if (it != mapKeyMetadata.end()) {
            return std::make_unique<CKeyMetadata>(it->second);
        }
    }
 
    CScript scriptPubKey = GetScriptForDestination(dest);
    auto it = m_script_metadata.find(CScriptID(scriptPubKey));
    if (it != m_script_metadata.end()) {
        return std::make_unique<CKeyMetadata>(it->second);
    }
 
    return nullptr;
}
 
uint256 LegacyScriptPubKeyMan::GetID() const {
    return uint256::ONE;
}
 
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) {
    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 (!m_storage.WithEncryptionKey(
            [&](const CKeyingMaterial &encryption_key) {
                return EncryptSecret(encryption_key, 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,
    bool checksum_valid) {
    // Set fDecryptionThoroughlyChecked to false when the checksum is invalid
    if (!checksum_valid) {
        fDecryptionThoroughlyChecked = false;
    }
 
    return AddCryptedKeyInner(vchPubKey, vchCryptedSecret);
}
 
bool LegacyScriptPubKeyMan::AddCryptedKeyInner(
    const CPubKey &vchPubKey, const std::vector<uint8_t> &vchCryptedSecret) {
    LOCK(cs_KeyStore);
    assert(mapKeys.empty());
 
    mapCryptedKeys[vchPubKey.GetID()] = make_pair(vchPubKey, vchCryptedSecret);
    return true;
}
 
bool LegacyScriptPubKeyMan::AddCryptedKey(
    const CPubKey &vchPubKey, const std::vector<uint8_t> &vchCryptedSecret) {
    if (!AddCryptedKeyInner(vchPubKey, vchCryptedSecret)) {
        return false;
    }
 
    LOCK(cs_KeyStore);
    if (encrypted_batch) {
        return encrypted_batch->WriteCryptedKey(
            vchPubKey, vchCryptedSecret, mapKeyMetadata[vchPubKey.GetID()]);
    }
 
    return WalletBatch(m_storage.GetDatabase())
        .WriteCryptedKey(vchPubKey, vchCryptedSecret,
                         mapKeyMetadata[vchPubKey.GetID()]);
}
 
bool LegacyScriptPubKeyMan::HaveWatchOnly(const CScript &dest) const {
    LOCK(cs_KeyStore);
    return setWatchOnly.count(dest) > 0;
}
 
bool LegacyScriptPubKeyMan::HaveWatchOnly() const {
    LOCK(cs_KeyStore);
    return (!setWatchOnly.empty());
}
 
static bool ExtractPubKey(const CScript &dest, CPubKey &pubKeyOut) {
    std::vector<std::vector<uint8_t>> solutions;
    return Solver(dest, solutions) == TxoutType::PUBKEY &&
           (pubKeyOut = CPubKey(solutions[0])).IsFullyValid();
}
 
bool LegacyScriptPubKeyMan::RemoveWatchOnly(const CScript &dest) {
    {
        LOCK(cs_KeyStore);
        setWatchOnly.erase(dest);
        CPubKey pubKey;
        if (ExtractPubKey(dest, pubKey)) {
            mapWatchKeys.erase(pubKey.GetID());
        }
    }
 
    if (!HaveWatchOnly()) {
        NotifyWatchonlyChanged(false);
    }
 
    return WalletBatch(m_storage.GetDatabase()).EraseWatchOnly(dest);
}
 
bool LegacyScriptPubKeyMan::LoadWatchOnly(const CScript &dest) {
    return AddWatchOnlyInMem(dest);
}
 
bool LegacyScriptPubKeyMan::AddWatchOnlyInMem(const CScript &dest) {
    LOCK(cs_KeyStore);
    setWatchOnly.insert(dest);
    CPubKey pubKey;
    if (ExtractPubKey(dest, pubKey)) {
        mapWatchKeys[pubKey.GetID()] = pubKey;
    }
    return true;
}
 
bool LegacyScriptPubKeyMan::AddWatchOnlyWithDB(WalletBatch &batch,
                                               const CScript &dest) {
    if (!AddWatchOnlyInMem(dest)) {
        return false;
    }
 
    const CKeyMetadata &meta = m_script_metadata[CScriptID(dest)];
    UpdateTimeFirstKey(meta.nCreateTime);
    NotifyWatchonlyChanged(true);
    if (batch.WriteWatchOnly(dest, meta)) {
        m_storage.UnsetBlankWalletFlag(batch);
        return true;
    }
    return false;
}
 
bool LegacyScriptPubKeyMan::AddWatchOnlyWithDB(WalletBatch &batch,
                                               const CScript &dest,
                                               int64_t create_time) {
    m_script_metadata[CScriptID(dest)].nCreateTime = create_time;
    return AddWatchOnlyWithDB(batch, dest);
}
 
bool LegacyScriptPubKeyMan::AddWatchOnly(const CScript &dest) {
    WalletBatch batch(m_storage.GetDatabase());
    return AddWatchOnlyWithDB(batch, dest);
}
 
bool LegacyScriptPubKeyMan::AddWatchOnly(const CScript &dest,
                                         int64_t nCreateTime) {
    m_script_metadata[CScriptID(dest)].nCreateTime = nCreateTime;
    return AddWatchOnly(dest);
}
 
void LegacyScriptPubKeyMan::LoadHDChain(const CHDChain &chain) {
    LOCK(cs_KeyStore);
    m_hd_chain = chain;
}
 
void LegacyScriptPubKeyMan::AddHDChain(const CHDChain &chain) {
    LOCK(cs_KeyStore);
    // Store the new chain
    if (!WalletBatch(m_storage.GetDatabase()).WriteHDChain(chain)) {
        throw std::runtime_error(std::string(__func__) +
                                 ": writing chain failed");
    }
    // When there's an old chain, add it as an inactive chain as we are now
    // rotating hd chains
    if (!m_hd_chain.seed_id.IsNull()) {
        AddInactiveHDChain(m_hd_chain);
    }
 
    m_hd_chain = chain;
}
 
void LegacyScriptPubKeyMan::AddInactiveHDChain(const CHDChain &chain) {
    LOCK(cs_KeyStore);
    assert(!chain.seed_id.IsNull());
    m_inactive_hd_chains[chain.seed_id] = 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 m_storage.WithEncryptionKey(
            [&](const CKeyingMaterial &encryption_key) {
                return DecryptKey(encryption_key, 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,
                                              CHDChain &hd_chain,
                                              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, hd_chain,
            (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;
}
 
void LegacyScriptPubKeyMan::DeriveNewChildKey(WalletBatch &batch,
                                              CKeyMetadata &metadata,
                                              CKey &secret, CHDChain &hd_chain,
                                              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(hd_chain.seed_id, seed)) {
        throw std::runtime_error(std::string(__func__) + ": seed not found");
    }
 
    masterKey.SetSeed(seed);
 
    // 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, hd_chain.nInternalChainCounter |
                                               BIP32_HARDENED_KEY_LIMIT);
            metadata.hdKeypath =
                "m/0'/1'/" + ToString(hd_chain.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(hd_chain.nInternalChainCounter |
                                               BIP32_HARDENED_KEY_LIMIT);
            hd_chain.nInternalChainCounter++;
        } else {
            chainChildKey.Derive(childKey, hd_chain.nExternalChainCounter |
                                               BIP32_HARDENED_KEY_LIMIT);
            metadata.hdKeypath =
                "m/0'/0'/" + ToString(hd_chain.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(hd_chain.nExternalChainCounter |
                                               BIP32_HARDENED_KEY_LIMIT);
            hd_chain.nExternalChainCounter++;
        }
    } while (HaveKey(childKey.key.GetPubKey().GetID()));
    secret = childKey.key;
    metadata.hd_seed_id = hd_chain.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 (hd_chain.seed_id == m_hd_chain.seed_id &&
        !batch.WriteHDChain(hd_chain)) {
        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();
    AddHDChain(newHdChain);
    NotifyCanGetAddressesChanged();
    WalletBatch batch(m_storage.GetDatabase());
    m_storage.UnsetBlankWalletFlag(batch);
}
 
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.GetIntArg("-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, m_hd_chain, 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, m_hd_chain, 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;
    ret.reserve(out.pubkeys.size());
    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::SetInternal(bool internal) {}
 
util::Result<CTxDestination>
DescriptorScriptPubKeyMan::GetNewDestination(const OutputType type) {
    // Returns true if this descriptor supports getting new addresses.
    // Conditions where we may be unable to fetch them (e.g. locked) are caught
    // later
    if (!CanGetAddresses(m_internal)) {
        return util::Error{_("No addresses available")};
    }
    {
        LOCK(cs_desc_man);
        // This is a combo descriptor which should not be an active descriptor
        assert(m_wallet_descriptor.descriptor->IsSingleType());
        std::optional<OutputType> desc_addr_type =
            m_wallet_descriptor.descriptor->GetOutputType();
        assert(desc_addr_type);
        if (type != *desc_addr_type) {
            throw std::runtime_error(std::string(__func__) +
                                     ": Types are inconsistent");
        }
 
        TopUp();
 
        // Get the scriptPubKey from the descriptor
        FlatSigningProvider out_keys;
        std::vector<CScript> scripts_temp;
        if (m_wallet_descriptor.range_end <= m_max_cached_index && !TopUp(1)) {
            // We can't generate anymore keys
            return util::Error{
                _("Error: Keypool ran out, please call keypoolrefill first")};
        }
        if (!m_wallet_descriptor.descriptor->ExpandFromCache(
                m_wallet_descriptor.next_index, m_wallet_descriptor.cache,
                scripts_temp, out_keys)) {
            // We can't generate anymore keys
            return util::Error{
                _("Error: Keypool ran out, please call keypoolrefill first")};
        }
 
        CTxDestination dest;
        std::optional<OutputType> out_script_type =
            m_wallet_descriptor.descriptor->GetOutputType();
        if (out_script_type && out_script_type == type) {
            ExtractDestination(scripts_temp[0], dest);
        } else {
            throw std::runtime_error(
                std::string(__func__) +
                ": Types are inconsistent. Stored type does not match type of "
                "newly generated address");
        }
        m_wallet_descriptor.next_index++;
        WalletBatch(m_storage.GetDatabase())
            .WriteDescriptor(GetID(), m_wallet_descriptor);
        return dest;
    }
}
 
isminetype DescriptorScriptPubKeyMan::IsMine(const CScript &script) const {
    LOCK(cs_desc_man);
    if (m_map_script_pub_keys.count(script) > 0) {
        return ISMINE_SPENDABLE;
    }
    return ISMINE_NO;
}
 
bool DescriptorScriptPubKeyMan::CheckDecryptionKey(
    const CKeyingMaterial &master_key, bool accept_no_keys) {
    LOCK(cs_desc_man);
    if (!m_map_keys.empty()) {
        return false;
    }
 
    // Always pass when there are no encrypted keys
    bool keyPass = m_map_crypted_keys.empty();
    bool keyFail = false;
    for (const auto &mi : m_map_crypted_keys) {
        const CPubKey &pubkey = mi.second.first;
        const std::vector<uint8_t> &crypted_secret = mi.second.second;
        CKey key;
        if (!DecryptKey(master_key, crypted_secret, pubkey, key)) {
            keyFail = true;
            break;
        }
        keyPass = true;
        if (m_decryption_thoroughly_checked) {
            break;
        }
    }
    if (keyPass && keyFail) {
        LogPrintf("The wallet is probably corrupted: Some keys decrypt but not "
                  "all.\n");
        throw std::runtime_error(
            "Error unlocking wallet: some keys decrypt but not all. Your "
            "wallet file may be corrupt.");
    }
    if (keyFail || (!keyPass && !accept_no_keys)) {
        return false;
    }
    m_decryption_thoroughly_checked = true;
    return true;
}
 
bool DescriptorScriptPubKeyMan::Encrypt(const CKeyingMaterial &master_key,
                                        WalletBatch *batch) {
    LOCK(cs_desc_man);
    if (!m_map_crypted_keys.empty()) {
        return false;
    }
 
    for (const KeyMap::value_type &key_in : m_map_keys) {
        const CKey &key = key_in.second;
        CPubKey pubkey = key.GetPubKey();
        CKeyingMaterial secret(key.begin(), key.end());
        std::vector<uint8_t> crypted_secret;
        if (!EncryptSecret(master_key, secret, pubkey.GetHash(),
                           crypted_secret)) {
            return false;
        }
        m_map_crypted_keys[pubkey.GetID()] = make_pair(pubkey, crypted_secret);
        batch->WriteCryptedDescriptorKey(GetID(), pubkey, crypted_secret);
    }
    m_map_keys.clear();
    return true;
}
 
bool DescriptorScriptPubKeyMan::GetReservedDestination(const OutputType type,
                                                       bool internal,
                                                       CTxDestination &address,
                                                       int64_t &index,
                                                       CKeyPool &keypool) {
    LOCK(cs_desc_man);
    auto op_dest = GetNewDestination(type);
    index = m_wallet_descriptor.next_index - 1;
    if (op_dest) {
        address = *op_dest;
    }
    return bool{op_dest};
}
 
void DescriptorScriptPubKeyMan::ReturnDestination(int64_t index, bool internal,
                                                  const CTxDestination &addr) {
    LOCK(cs_desc_man);
    // Only return when the index was the most recent
    if (m_wallet_descriptor.next_index - 1 == index) {
        m_wallet_descriptor.next_index--;
    }
    WalletBatch(m_storage.GetDatabase())
        .WriteDescriptor(GetID(), m_wallet_descriptor);
    NotifyCanGetAddressesChanged();
}
 
std::map<CKeyID, CKey> DescriptorScriptPubKeyMan::GetKeys() const {
    AssertLockHeld(cs_desc_man);
    if (m_storage.HasEncryptionKeys() && !m_storage.IsLocked()) {
        KeyMap keys;
        for (const auto &key_pair : m_map_crypted_keys) {
            const CPubKey &pubkey = key_pair.second.first;
            const std::vector<uint8_t> &crypted_secret = key_pair.second.second;
            CKey key;
            m_storage.WithEncryptionKey(
                [&](const CKeyingMaterial &encryption_key) {
                    return DecryptKey(encryption_key, crypted_secret, pubkey,
                                      key);
                });
            keys[pubkey.GetID()] = key;
        }
        return keys;
    }
    return m_map_keys;
}
 
bool DescriptorScriptPubKeyMan::TopUp(unsigned int size) {
    LOCK(cs_desc_man);
    unsigned int target_size;
    if (size > 0) {
        target_size = size;
    } else {
        target_size = std::max(
            gArgs.GetIntArg("-keypool", DEFAULT_KEYPOOL_SIZE), int64_t(1));
    }
 
    // Calculate the new range_end
    int32_t new_range_end =
        std::max(m_wallet_descriptor.next_index + int32_t(target_size),
                 m_wallet_descriptor.range_end);
 
    // If the descriptor is not ranged, we actually just want to fill the first
    // cache item
    if (!m_wallet_descriptor.descriptor->IsRange()) {
        new_range_end = 1;
        m_wallet_descriptor.range_end = 1;
        m_wallet_descriptor.range_start = 0;
    }
 
    FlatSigningProvider provider;
    provider.keys = GetKeys();
 
    WalletBatch batch(m_storage.GetDatabase());
    uint256 id = GetID();
    for (int32_t i = m_max_cached_index + 1; i < new_range_end; ++i) {
        FlatSigningProvider out_keys;
        std::vector<CScript> scripts_temp;
        DescriptorCache temp_cache;
        // Maybe we have a cached xpub and we can expand from the cache first
        if (!m_wallet_descriptor.descriptor->ExpandFromCache(
                i, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
            if (!m_wallet_descriptor.descriptor->Expand(
                    i, provider, scripts_temp, out_keys, &temp_cache)) {
                return false;
            }
        }
        // Add all of the scriptPubKeys to the scriptPubKey set
        for (const CScript &script : scripts_temp) {
            m_map_script_pub_keys[script] = i;
        }
        for (const auto &pk_pair : out_keys.pubkeys) {
            const CPubKey &pubkey = pk_pair.second;
            if (m_map_pubkeys.count(pubkey) != 0) {
                // We don't need to give an error here.
                // It doesn't matter which of many valid indexes the pubkey has,
                // we just need an index where we can derive it and it's private
                // key
                continue;
            }
            m_map_pubkeys[pubkey] = i;
        }
        // Write the cache
        for (const auto &parent_xpub_pair :
             temp_cache.GetCachedParentExtPubKeys()) {
            CExtPubKey xpub;
            if (m_wallet_descriptor.cache.GetCachedParentExtPubKey(
                    parent_xpub_pair.first, xpub)) {
                if (xpub != parent_xpub_pair.second) {
                    throw std::runtime_error(
                        std::string(__func__) +
                        ": New cached parent xpub does not match already "
                        "cached parent xpub");
                }
                continue;
            }
            if (!batch.WriteDescriptorParentCache(parent_xpub_pair.second, id,
                                                  parent_xpub_pair.first)) {
                throw std::runtime_error(std::string(__func__) +
                                         ": writing cache item failed");
            }
            m_wallet_descriptor.cache.CacheParentExtPubKey(
                parent_xpub_pair.first, parent_xpub_pair.second);
        }
        for (const auto &derived_xpub_map_pair :
             temp_cache.GetCachedDerivedExtPubKeys()) {
            for (const auto &derived_xpub_pair : derived_xpub_map_pair.second) {
                CExtPubKey xpub;
                if (m_wallet_descriptor.cache.GetCachedDerivedExtPubKey(
                        derived_xpub_map_pair.first, derived_xpub_pair.first,
                        xpub)) {
                    if (xpub != derived_xpub_pair.second) {
                        throw std::runtime_error(
                            std::string(__func__) +
                            ": New cached derived xpub does not match already "
                            "cached derived xpub");
                    }
                    continue;
                }
                if (!batch.WriteDescriptorDerivedCache(
                        derived_xpub_pair.second, id,
                        derived_xpub_map_pair.first, derived_xpub_pair.first)) {
                    throw std::runtime_error(std::string(__func__) +
                                             ": writing cache item failed");
                }
                m_wallet_descriptor.cache.CacheDerivedExtPubKey(
                    derived_xpub_map_pair.first, derived_xpub_pair.first,
                    derived_xpub_pair.second);
            }
        }
        m_max_cached_index++;
    }
    m_wallet_descriptor.range_end = new_range_end;
    batch.WriteDescriptor(GetID(), m_wallet_descriptor);
 
    // By this point, the cache size should be the size of the entire range
    assert(m_wallet_descriptor.range_end - 1 == m_max_cached_index);
 
    NotifyCanGetAddressesChanged();
    return true;
}
 
void DescriptorScriptPubKeyMan::MarkUnusedAddresses(const CScript &script) {
    LOCK(cs_desc_man);
    if (IsMine(script)) {
        int32_t index = m_map_script_pub_keys[script];
        if (index >= m_wallet_descriptor.next_index) {
            WalletLogPrintf("%s: Detected a used keypool item at index %d, "
                            "mark all keypool items up to this item as used\n",
                            __func__, index);
            m_wallet_descriptor.next_index = index + 1;
        }
        if (!TopUp()) {
            WalletLogPrintf("%s: Topping up keypool failed (locked wallet)\n",
                            __func__);
        }
    }
}
 
void DescriptorScriptPubKeyMan::AddDescriptorKey(const CKey &key,
                                                 const CPubKey &pubkey) {
    LOCK(cs_desc_man);
    WalletBatch batch(m_storage.GetDatabase());
    if (!AddDescriptorKeyWithDB(batch, key, pubkey)) {
        throw std::runtime_error(std::string(__func__) +
                                 ": writing descriptor private key failed");
    }
}
 
bool DescriptorScriptPubKeyMan::AddDescriptorKeyWithDB(WalletBatch &batch,
                                                       const CKey &key,
                                                       const CPubKey &pubkey) {
    AssertLockHeld(cs_desc_man);
    assert(!m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
 
    // Check if provided key already exists
    if (m_map_keys.find(pubkey.GetID()) != m_map_keys.end() ||
        m_map_crypted_keys.find(pubkey.GetID()) != m_map_crypted_keys.end()) {
        return true;
    }
 
    if (m_storage.HasEncryptionKeys()) {
        if (m_storage.IsLocked()) {
            return false;
        }
 
        std::vector<uint8_t> crypted_secret;
        CKeyingMaterial secret(key.begin(), key.end());
        if (!m_storage.WithEncryptionKey(
                [&](const CKeyingMaterial &encryption_key) {
                    return EncryptSecret(encryption_key, secret,
                                         pubkey.GetHash(), crypted_secret);
                })) {
            return false;
        }
 
        m_map_crypted_keys[pubkey.GetID()] = make_pair(pubkey, crypted_secret);
        return batch.WriteCryptedDescriptorKey(GetID(), pubkey, crypted_secret);
    } else {
        m_map_keys[pubkey.GetID()] = key;
        return batch.WriteDescriptorKey(GetID(), pubkey, key.GetPrivKey());
    }
}
 
bool DescriptorScriptPubKeyMan::SetupDescriptorGeneration(
    const CExtKey &master_key, OutputType addr_type) {
    LOCK(cs_desc_man);
    assert(m_storage.IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
 
    // Ignore when there is already a descriptor
    if (m_wallet_descriptor.descriptor) {
        return false;
    }
 
    int64_t creation_time = GetTime();
 
    std::string xpub = EncodeExtPubKey(master_key.Neuter());
 
    // Build descriptor string
    std::string desc_prefix;
    std::string desc_suffix = "/*)";
    switch (addr_type) {
        case OutputType::LEGACY: {
            desc_prefix = "pkh(" + xpub + "/44'";
            break;
        }
    } // no default case, so the compiler can warn about missing cases
    assert(!desc_prefix.empty());
 
    // Mainnet derives at 0', testnet and regtest derive at 1'
    if (m_storage.GetChainParams().IsTestChain()) {
        desc_prefix += "/1'";
    } else {
        desc_prefix += "/0'";
    }
 
    std::string internal_path = m_internal ? "/1" : "/0";
    std::string desc_str = desc_prefix + "/0'" + internal_path + desc_suffix;
 
    // Make the descriptor
    FlatSigningProvider keys;
    std::string error;
    std::unique_ptr<Descriptor> desc = Parse(desc_str, keys, error, false);
    WalletDescriptor w_desc(std::move(desc), creation_time, 0, 0, 0);
    m_wallet_descriptor = w_desc;
 
    // Store the master private key, and descriptor
    WalletBatch batch(m_storage.GetDatabase());
    if (!AddDescriptorKeyWithDB(batch, master_key.key,
                                master_key.key.GetPubKey())) {
        throw std::runtime_error(
            std::string(__func__) +
            ": writing descriptor master private key failed");
    }
    if (!batch.WriteDescriptor(GetID(), m_wallet_descriptor)) {
        throw std::runtime_error(std::string(__func__) +
                                 ": writing descriptor failed");
    }
 
    // TopUp
    TopUp();
 
    m_storage.UnsetBlankWalletFlag(batch);
    return true;
}
 
bool DescriptorScriptPubKeyMan::IsHDEnabled() const {
    LOCK(cs_desc_man);
    return m_wallet_descriptor.descriptor->IsRange();
}
 
bool DescriptorScriptPubKeyMan::CanGetAddresses(bool internal) const {
    // We can only give out addresses from descriptors that are single type (not
    // combo), ranged, and either have cached keys or can generate more keys
    // (ignoring encryption)
    LOCK(cs_desc_man);
    return m_wallet_descriptor.descriptor->IsSingleType() &&
           m_wallet_descriptor.descriptor->IsRange() &&
           (HavePrivateKeys() ||
            m_wallet_descriptor.next_index < m_wallet_descriptor.range_end);
}
 
bool DescriptorScriptPubKeyMan::HavePrivateKeys() const {
    LOCK(cs_desc_man);
    return m_map_keys.size() > 0 || m_map_crypted_keys.size() > 0;
}
 
int64_t DescriptorScriptPubKeyMan::GetOldestKeyPoolTime() const {
    // This is only used for getwalletinfo output and isn't relevant to
    // descriptor wallets. The magic number 0 indicates that it shouldn't be
    // displayed so that's what we return.
    return 0;
}
 
size_t DescriptorScriptPubKeyMan::KeypoolCountExternalKeys() const {
    if (m_internal) {
        return 0;
    }
    return GetKeyPoolSize();
}
 
unsigned int DescriptorScriptPubKeyMan::GetKeyPoolSize() const {
    LOCK(cs_desc_man);
    return m_wallet_descriptor.range_end - m_wallet_descriptor.next_index;
}
 
int64_t DescriptorScriptPubKeyMan::GetTimeFirstKey() const {
    LOCK(cs_desc_man);
    return m_wallet_descriptor.creation_time;
}
 
std::unique_ptr<FlatSigningProvider>
DescriptorScriptPubKeyMan::GetSigningProvider(const CScript &script,
                                              bool include_private) const {
    LOCK(cs_desc_man);
 
    // Find the index of the script
    auto it = m_map_script_pub_keys.find(script);
    if (it == m_map_script_pub_keys.end()) {
        return nullptr;
    }
    int32_t index = it->second;
 
    return GetSigningProvider(index, include_private);
}
 
std::unique_ptr<FlatSigningProvider>
DescriptorScriptPubKeyMan::GetSigningProvider(const CPubKey &pubkey) const {
    LOCK(cs_desc_man);
 
    // Find index of the pubkey
    auto it = m_map_pubkeys.find(pubkey);
    if (it == m_map_pubkeys.end()) {
        return nullptr;
    }
    int32_t index = it->second;
 
    // Always try to get the signing provider with private keys. This function
    // should only be called during signing anyways
    return GetSigningProvider(index, true);
}
 
std::unique_ptr<FlatSigningProvider>
DescriptorScriptPubKeyMan::GetSigningProvider(int32_t index,
                                              bool include_private) const {
    AssertLockHeld(cs_desc_man);
    // Get the scripts, keys, and key origins for this script
    std::unique_ptr<FlatSigningProvider> out_keys =
        std::make_unique<FlatSigningProvider>();
    std::vector<CScript> scripts_temp;
    if (!m_wallet_descriptor.descriptor->ExpandFromCache(
            index, m_wallet_descriptor.cache, scripts_temp, *out_keys)) {
        return nullptr;
    }
 
    if (HavePrivateKeys() && include_private) {
        FlatSigningProvider master_provider;
        master_provider.keys = GetKeys();
        m_wallet_descriptor.descriptor->ExpandPrivate(index, master_provider,
                                                      *out_keys);
    }
 
    return out_keys;
}
 
std::unique_ptr<SigningProvider>
DescriptorScriptPubKeyMan::GetSolvingProvider(const CScript &script) const {
    return GetSigningProvider(script, false);
}
 
bool DescriptorScriptPubKeyMan::CanProvide(const CScript &script,
                                           SignatureData &sigdata) {
    return IsMine(script);
}
 
bool DescriptorScriptPubKeyMan::SignTransaction(
    CMutableTransaction &tx, const std::map<COutPoint, Coin> &coins,
    SigHashType sighash, std::map<int, std::string> &input_errors) const {
    std::unique_ptr<FlatSigningProvider> keys =
        std::make_unique<FlatSigningProvider>();
    for (const auto &coin_pair : coins) {
        std::unique_ptr<FlatSigningProvider> coin_keys =
            GetSigningProvider(coin_pair.second.GetTxOut().scriptPubKey, true);
        if (!coin_keys) {
            continue;
        }
        *keys = Merge(*keys, *coin_keys);
    }
 
    return ::SignTransaction(tx, keys.get(), coins, sighash, input_errors);
}
 
SigningResult
DescriptorScriptPubKeyMan::SignMessage(const std::string &message,
                                       const PKHash &pkhash,
                                       std::string &str_sig) const {
    std::unique_ptr<FlatSigningProvider> keys =
        GetSigningProvider(GetScriptForDestination(pkhash), true);
    if (!keys) {
        return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
    }
 
    CKey key;
    if (!keys->GetKey(ToKeyID(pkhash), key)) {
        return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
    }
 
    if (!MessageSign(key, message, str_sig)) {
        return SigningResult::SIGNING_FAILED;
    }
    return SigningResult::OK;
}
 
std::optional<PSBTError>
DescriptorScriptPubKeyMan::FillPSBT(PartiallySignedTransaction &psbtx,
                                    SigHashType sighash_type, bool sign,
                                    bool bip32derivs, bool finalize) const {
    for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
        PSBTInput &input = psbtx.inputs.at(i);
 
        if (PSBTInputSigned(input)) {
            continue;
        }
 
        // Get the Sighash type
        if (sign && input.sighash_type != std::nullopt &&
            *input.sighash_type != sighash_type) {
            return PSBTError::SIGHASH_MISMATCH;
        }
 
        // Get the scriptPubKey to know which SigningProvider to use
        CScript script;
        if (!input.utxo.IsNull()) {
            script = input.utxo.scriptPubKey;
        } else {
            // There's no UTXO so we can just skip this now
            continue;
        }
        SignatureData sigdata;
        input.FillSignatureData(sigdata);
 
        std::unique_ptr<FlatSigningProvider> keys =
            std::make_unique<FlatSigningProvider>();
        std::unique_ptr<FlatSigningProvider> script_keys =
            GetSigningProvider(script, sign);
        if (script_keys) {
            *keys = Merge(*keys, *script_keys);
        } else {
            // Maybe there are pubkeys listed that we can sign for
            script_keys = std::make_unique<FlatSigningProvider>();
            for (const auto &pk_pair : input.hd_keypaths) {
                const CPubKey &pubkey = pk_pair.first;
                std::unique_ptr<FlatSigningProvider> pk_keys =
                    GetSigningProvider(pubkey);
                if (pk_keys) {
                    *keys = Merge(*keys, *pk_keys);
                }
            }
        }
 
        SignPSBTInput(HidingSigningProvider(keys.get(), !sign, !bip32derivs),
                      psbtx, i, sighash_type, /*out_sigdata=*/nullptr,
                      /*use_dummy=*/false, finalize);
    }
 
    // Fill in the bip32 keypaths and redeemscripts for the outputs so that
    // hardware wallets can identify change
    for (size_t i = 0; i < psbtx.tx->vout.size(); ++i) {
        std::unique_ptr<SigningProvider> keys =
            GetSolvingProvider(psbtx.tx->vout.at(i).scriptPubKey);
        if (!keys) {
            continue;
        }
        UpdatePSBTOutput(HidingSigningProvider(keys.get(), true, !bip32derivs),
                         psbtx, i);
    }
 
    return {};
}
 
std::unique_ptr<CKeyMetadata>
DescriptorScriptPubKeyMan::GetMetadata(const CTxDestination &dest) const {
    std::unique_ptr<SigningProvider> provider =
        GetSigningProvider(GetScriptForDestination(dest));
    if (provider) {
        KeyOriginInfo orig;
        CKeyID key_id = GetKeyForDestination(*provider, dest);
        if (provider->GetKeyOrigin(key_id, orig)) {
            LOCK(cs_desc_man);
            std::unique_ptr<CKeyMetadata> meta =
                std::make_unique<CKeyMetadata>();
            meta->key_origin = orig;
            meta->has_key_origin = true;
            meta->nCreateTime = m_wallet_descriptor.creation_time;
            return meta;
        }
    }
    return nullptr;
}
 
uint256 DescriptorScriptPubKeyMan::GetID() const {
    LOCK(cs_desc_man);
    std::string desc_str = m_wallet_descriptor.descriptor->ToString();
    uint256 id;
    CSHA256()
        .Write((uint8_t *)desc_str.data(), desc_str.size())
        .Finalize(id.begin());
    return id;
}
 
void DescriptorScriptPubKeyMan::SetInternal(bool internal) {
    this->m_internal = internal;
}
 
void DescriptorScriptPubKeyMan::SetCache(const DescriptorCache &cache) {
    LOCK(cs_desc_man);
    m_wallet_descriptor.cache = cache;
    for (int32_t i = m_wallet_descriptor.range_start;
         i < m_wallet_descriptor.range_end; ++i) {
        FlatSigningProvider out_keys;
        std::vector<CScript> scripts_temp;
        if (!m_wallet_descriptor.descriptor->ExpandFromCache(
                i, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
            throw std::runtime_error(
                "Error: Unable to expand wallet descriptor from cache");
        }
        // Add all of the scriptPubKeys to the scriptPubKey set
        for (const CScript &script : scripts_temp) {
            if (m_map_script_pub_keys.count(script) != 0) {
                throw std::runtime_error(
                    strprintf("Error: Already loaded script at index %d as "
                              "being at index %d",
                              i, m_map_script_pub_keys[script]));
            }
            m_map_script_pub_keys[script] = i;
        }
        for (const auto &pk_pair : out_keys.pubkeys) {
            const CPubKey &pubkey = pk_pair.second;
            if (m_map_pubkeys.count(pubkey) != 0) {
                // We don't need to give an error here.
                // It doesn't matter which of many valid indexes the pubkey has,
                // we just need an index where we can derive it and it's private
                // key
                continue;
            }
            m_map_pubkeys[pubkey] = i;
        }
        m_max_cached_index++;
    }
}
 
bool DescriptorScriptPubKeyMan::AddKey(const CKeyID &key_id, const CKey &key) {
    LOCK(cs_desc_man);
    m_map_keys[key_id] = key;
    return true;
}
 
bool DescriptorScriptPubKeyMan::AddCryptedKey(
    const CKeyID &key_id, const CPubKey &pubkey,
    const std::vector<uint8_t> &crypted_key) {
    LOCK(cs_desc_man);
    if (!m_map_keys.empty()) {
        return false;
    }
 
    m_map_crypted_keys[key_id] = make_pair(pubkey, crypted_key);
    return true;
}
 
bool DescriptorScriptPubKeyMan::HasWalletDescriptor(
    const WalletDescriptor &desc) const {
    LOCK(cs_desc_man);
    return m_wallet_descriptor.descriptor != nullptr &&
           desc.descriptor != nullptr &&
           m_wallet_descriptor.descriptor->ToString() ==
               desc.descriptor->ToString();
}
 
void DescriptorScriptPubKeyMan::WriteDescriptor() {
    LOCK(cs_desc_man);
    WalletBatch batch(m_storage.GetDatabase());
    if (!batch.WriteDescriptor(GetID(), m_wallet_descriptor)) {
        throw std::runtime_error(std::string(__func__) +
                                 ": writing descriptor failed");
    }
}
 
WalletDescriptor DescriptorScriptPubKeyMan::GetWalletDescriptor() const {
    return m_wallet_descriptor;
}
 
std::vector<CScript> DescriptorScriptPubKeyMan::GetScriptPubKeys() const {
    LOCK(cs_desc_man);
    std::vector<CScript> script_pub_keys;
    script_pub_keys.reserve(m_map_script_pub_keys.size());
 
    for (auto const &script_pub_key : m_map_script_pub_keys) {
        script_pub_keys.push_back(script_pub_key.first);
    }
    return script_pub_keys;
}
 
void DescriptorScriptPubKeyMan::UpdateWalletDescriptor(
    WalletDescriptor &descriptor) {
    LOCK(cs_desc_man);
    std::string error;
    if (!CanUpdateToWalletDescriptor(descriptor, error)) {
        throw std::runtime_error(std::string(__func__) + ": " + error);
    }
 
    m_map_pubkeys.clear();
    m_map_script_pub_keys.clear();
    m_max_cached_index = -1;
    m_wallet_descriptor = descriptor;
}
 
bool DescriptorScriptPubKeyMan::CanUpdateToWalletDescriptor(
    const WalletDescriptor &descriptor, std::string &error) {
    LOCK(cs_desc_man);
    if (!HasWalletDescriptor(descriptor)) {
        error = "can only update matching descriptor";
        return false;
    }
 
    if (descriptor.range_start > m_wallet_descriptor.range_start ||
        descriptor.range_end < m_wallet_descriptor.range_end) {
        // Use inclusive range for error
        error = strprintf("new range must include current range = [%d,%d]",
                          m_wallet_descriptor.range_start,
                          m_wallet_descriptor.range_end - 1);
        return false;
    }
 
    return true;
}