251    }
252    return true;
253}
254
255std::unique_ptr<SigningProvider> LegacyDataSPKM::GetSolvingProvider(const CScript& script) const
256{
257    return std::make_unique<LegacySigningProvider>(*this);
258}
259
260bool LegacyDataSPKM::CanProvide(const CScript& script, SignatureData& sigdata)
261{
262    IsMineResult ismine = LegacyWalletIsMineInnerDONOTUSE(*this, script, IsMineSigVersion::TOP, /* recurse_scripthash= */ false);
263    if (ismine == IsMineResult::SPENDABLE || ismine == IsMineResult::WATCH_ONLY) {
264        // If ismine, it means we recognize keys or script ids in the script, or
265        // are watching the script itself, and we can at least provide metadata
266        // or solving information, even if not able to sign fully.
267        return true;
268    } else {
269        // If, given the stuff in sigdata, we could make a valid signature, then we can provide for this script
270        ProduceSignature(*this, DUMMY_SIGNATURE_CREATOR, script, sigdata);
271        if (!sigdata.signatures.empty()) {
272            // If we could make signatures, make sure we have a private key to actually make a signature
273            bool has_privkeys = false;
274            for (const auto& key_sig_pair : sigdata.signatures) {
275                has_privkeys |= HaveKey(key_sig_pair.first);
276            }
277            return has_privkeys;
278        }
279        return false;
280    }
281}
282
283bool LegacyDataSPKM::LoadKey(const CKey& key, const CPubKey &pubkey)
284{
285    return AddKeyPubKeyInner(key, pubkey);
286}
287
288bool LegacyDataSPKM::LoadCScript(const CScript& redeemScript)
289{
290    /* A sanity check was added in pull #3843 to avoid adding redeemScripts
291     * that never can be redeemed. However, old wallets may still contain
292     * these. Do not add them to the wallet and warn. */
293    if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE)
294    {
295        std::string strAddr = EncodeDestination(ScriptHash(redeemScript));
296        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);
297        return true;
298    }
299
300    return FillableSigningProvider::AddCScript(redeemScript);
301}
302
303void LegacyDataSPKM::LoadKeyMetadata(const CKeyID& keyID, const CKeyMetadata& meta)
304{
305    LOCK(cs_KeyStore);
306    mapKeyMetadata[keyID] = meta;
307}
308
309void LegacyDataSPKM::LoadScriptMetadata(const CScriptID& script_id, const CKeyMetadata& meta)
310{
311    LOCK(cs_KeyStore);
312    m_script_metadata[script_id] = meta;
313}
314
315bool LegacyDataSPKM::AddKeyPubKeyInner(const CKey& key, const CPubKey& pubkey)
316{
317    LOCK(cs_KeyStore);
318    return FillableSigningProvider::AddKeyPubKey(key, pubkey);
319}
320
321bool LegacyDataSPKM::LoadCryptedKey(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret, bool checksum_valid)
322{
323    // Set fDecryptionThoroughlyChecked to false when the checksum is invalid
324    if (!checksum_valid) {
325        fDecryptionThoroughlyChecked = false;
326    }
327
328    return AddCryptedKeyInner(vchPubKey, vchCryptedSecret);
329}
330
331bool LegacyDataSPKM::AddCryptedKeyInner(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret)
332{
333    LOCK(cs_KeyStore);
334    assert(mapKeys.empty());
335
336    mapCryptedKeys[vchPubKey.GetID()] = make_pair(vchPubKey, vchCryptedSecret);
337    ImplicitlyLearnRelatedKeyScripts(vchPubKey);
338    return true;
339}
340
341bool LegacyDataSPKM::HaveWatchOnly(const CScript &dest) const
342{
343    LOCK(cs_KeyStore);
344    return setWatchOnly.contains(dest);
345}
346
347bool LegacyDataSPKM::LoadWatchOnly(const CScript &dest)
348{
349    return AddWatchOnlyInMem(dest);
350}
351
352static bool ExtractPubKey(const CScript &dest, CPubKey& pubKeyOut)
353{
354    std::vector<std::vector<unsigned char>> solutions;
355    return Solver(dest, solutions) == TxoutType::PUBKEY &&
356        (pubKeyOut = CPubKey(solutions[0])).IsFullyValid();
357}
358
359bool LegacyDataSPKM::AddWatchOnlyInMem(const CScript &dest)
360{
361    LOCK(cs_KeyStore);
362    setWatchOnly.insert(dest);
363    CPubKey pubKey;
364    if (ExtractPubKey(dest, pubKey)) {
365        mapWatchKeys[pubKey.GetID()] = pubKey;
366        ImplicitlyLearnRelatedKeyScripts(pubKey);
367    }
368    return true;
369}
370
371void LegacyDataSPKM::LoadHDChain(const CHDChain& chain)
372{
373    LOCK(cs_KeyStore);
374    m_hd_chain = chain;
375}
376
377void LegacyDataSPKM::AddInactiveHDChain(const CHDChain& chain)
378{
379    LOCK(cs_KeyStore);
380    assert(!chain.seed_id.IsNull());
381    m_inactive_hd_chains[chain.seed_id] = chain;
382}
383
384bool LegacyDataSPKM::HaveKey(const CKeyID &address) const
385{
386    LOCK(cs_KeyStore);
387    if (!m_storage.HasEncryptionKeys()) {
388        return FillableSigningProvider::HaveKey(address);
389    }
390    return mapCryptedKeys.contains(address);
391}
392
393bool LegacyDataSPKM::GetKey(const CKeyID &address, CKey& keyOut) const
394{
395    LOCK(cs_KeyStore);
396    if (!m_storage.HasEncryptionKeys()) {
397        return FillableSigningProvider::GetKey(address, keyOut);
398    }
399
400    CryptedKeyMap::const_iterator mi = mapCryptedKeys.find(address);
401    if (mi != mapCryptedKeys.end())
402    {
403        const CPubKey &vchPubKey = (*mi).second.first;
404        const std::vector<unsigned char> &vchCryptedSecret = (*mi).second.second;
405        return m_storage.WithEncryptionKey([&](const CKeyingMaterial& encryption_key) {
406            return DecryptKey(encryption_key, vchCryptedSecret, vchPubKey, keyOut);
407        });
408    }
409    return false;
410}
411
412bool LegacyDataSPKM::GetKeyOrigin(const CKeyID& keyID, KeyOriginInfo& info) const
413{
414    CKeyMetadata meta;
415    {
416        LOCK(cs_KeyStore);
417        auto it = mapKeyMetadata.find(keyID);
418        if (it == mapKeyMetadata.end()) {
419            return false;
420        }
421        meta = it->second;
422    }
423    if (meta.has_key_origin) {
424        info.fingerprint = meta.key_origin.fingerprint;
425        info.path = meta.key_origin.path;
426    } else { // Single pubkeys get the master fingerprint of themselves
427        info.fingerprint = keyID.fingerprint();
428    }
429    return true;
430}
431
432bool LegacyDataSPKM::GetWatchPubKey(const CKeyID &address, CPubKey &pubkey_out) const
433{
434    LOCK(cs_KeyStore);
435    WatchKeyMap::const_iterator it = mapWatchKeys.find(address);
436    if (it != mapWatchKeys.end()) {
437        pubkey_out = it->second;
438        return true;
439    }
440    return false;
441}
442
443bool LegacyDataSPKM::GetPubKey(const CKeyID &address, CPubKey& vchPubKeyOut) const
444{
445    LOCK(cs_KeyStore);
446    if (!m_storage.HasEncryptionKeys()) {
447        if (!FillableSigningProvider::GetPubKey(address, vchPubKeyOut)) {
448            return GetWatchPubKey(address, vchPubKeyOut);
449        }
450        return true;
451    }
452
453    CryptedKeyMap::const_iterator mi = mapCryptedKeys.find(address);
454    if (mi != mapCryptedKeys.end())
455    {
456        vchPubKeyOut = (*mi).second.first;
457        return true;
458    }
459    // Check for watch-only pubkeys
460    return GetWatchPubKey(address, vchPubKeyOut);
461}
462
463std::unordered_set<CScript, SaltedSipHasher> LegacyDataSPKM::GetCandidateScriptPubKeys() const
464{
465    LOCK(cs_KeyStore);
466    std::unordered_set<CScript, SaltedSipHasher> candidate_spks;
467
468    // For every private key in the wallet, there should be a P2PK, P2PKH, P2WPKH, and P2SH-P2WPKH
469    const auto& add_pubkey = [&candidate_spks](const CPubKey& pub) -> void {
470        candidate_spks.insert(GetScriptForRawPubKey(pub));
471        candidate_spks.insert(GetScriptForDestination(PKHash(pub)));
472
473        CScript wpkh = GetScriptForDestination(WitnessV0KeyHash(pub));
474        candidate_spks.insert(wpkh);
475        candidate_spks.insert(GetScriptForDestination(ScriptHash(wpkh)));
476    };
477    for (const auto& [_, key] : mapKeys) {
478        add_pubkey(key.GetPubKey());
479    }
480    for (const auto& [_, ckeypair] : mapCryptedKeys) {
481        add_pubkey(ckeypair.first);
482    }
483
484    // mapScripts contains all redeemScripts and witnessScripts. Therefore each script in it has
485    // itself, P2SH, P2WSH, and P2SH-P2WSH as a candidate.
486    // Invalid scripts such as P2SH-P2SH and P2WSH-P2SH, among others, will be added as candidates.
487    // Callers of this function will need to remove such scripts.
488    const auto& add_script = [&candidate_spks](const CScript& script) -> void {
489        candidate_spks.insert(script);
490        candidate_spks.insert(GetScriptForDestination(ScriptHash(script)));
491
492        CScript wsh = GetScriptForDestination(WitnessV0ScriptHash(script));
493        candidate_spks.insert(wsh);
494        candidate_spks.insert(GetScriptForDestination(ScriptHash(wsh)));
495    };
496    for (const auto& [_, script] : mapScripts) {
497        add_script(script);
498    }
499
500    // Although setWatchOnly should only contain output scripts, we will also include each script's