The wallet state and lifecycle

3501    // Search the cache for relevant SPKMs instead of iterating m_spk_managers
3502    const auto& it = m_cached_spks.find(script);
3503    if (it != m_cached_spks.end()) {
3504        spk_mans.insert(it->second.begin(), it->second.end());
3505    }
3506    SignatureData sigdata;
3507    Assume(std::all_of(spk_mans.begin(), spk_mans.end(), [&script, &sigdata](ScriptPubKeyMan* spkm) { return spkm->CanProvide(script, sigdata); }));
3508
3509    return spk_mans;
3510}
3511
3512ScriptPubKeyMan* CWallet::GetScriptPubKeyMan(const uint256& id) const
3513{
3514    if (m_spk_managers.contains(id)) {
3515        return m_spk_managers.at(id).get();
3516    }
3517    return nullptr;
3518}
3519
3520std::unique_ptr<SigningProvider> CWallet::GetSolvingProvider(const CScript& script) const
3521{
3522    SignatureData sigdata;
3523    return GetSolvingProvider(script, sigdata);
3524}
3525
3526std::unique_ptr<SigningProvider> CWallet::GetSolvingProvider(const CScript& script, SignatureData& sigdata) const
3527{
3528    // Search the cache for relevant SPKMs instead of iterating m_spk_managers
3529    const auto& it = m_cached_spks.find(script);
3530    if (it != m_cached_spks.end()) {
3531        // All spkms for a given script must already be able to make a SigningProvider for the script, so just return the first one.
3532        Assume(it->second.at(0)->CanProvide(script, sigdata));
3533        return it->second.at(0)->GetSolvingProvider(script);
3534    }
3535
3536    return nullptr;
3537}
3538
3539std::vector<WalletDescriptor> CWallet::GetWalletDescriptors(const CScript& script) const
3540{
3541    std::vector<WalletDescriptor> descs;
3542    for (const auto spk_man: GetScriptPubKeyMans(script)) {
3543        if (const auto desc_spk_man = dynamic_cast<DescriptorScriptPubKeyMan*>(spk_man)) {
3544            LOCK(desc_spk_man->cs_desc_man);
3545            descs.push_back(desc_spk_man->GetWalletDescriptor());
3546        }
3547    }
3548    return descs;
3549}
3550
3551LegacyDataSPKM* CWallet::GetLegacyDataSPKM() const
3552{
3553    if (IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
3554        return nullptr;
3555    }
3556    auto it = m_internal_spk_managers.find(OutputType::LEGACY);
3557    if (it == m_internal_spk_managers.end()) return nullptr;
3558    return dynamic_cast<LegacyDataSPKM*>(it->second);
3559}
3560
3561void CWallet::AddScriptPubKeyMan(const uint256& id, std::unique_ptr<ScriptPubKeyMan> spkm_man)
3562{
3563    // Add spkm_man to m_spk_managers before calling any method
3564    // that might access it.
3565    const auto& spkm = m_spk_managers[id] = std::move(spkm_man);
3566
3567    // Update birth time if needed
3568    MaybeUpdateBirthTime(spkm->GetTimeFirstKey());
3569}
3570
3571LegacyDataSPKM* CWallet::GetOrCreateLegacyDataSPKM()
3572{
3573    SetupLegacyDataSPKM();
3574    return GetLegacyDataSPKM();
3575}
3576
3577void CWallet::SetupLegacyDataSPKM()
3578{
3579    if (!m_internal_spk_managers.empty() || !m_external_spk_managers.empty() || !m_spk_managers.empty() || IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
3580        return;
3581    }
3582
3583    Assert(m_database->Format() == "bdb_ro" || m_database->Format() == "sqlite-mock");
3584    std::unique_ptr<ScriptPubKeyMan> spk_manager = std::make_unique<LegacyDataSPKM>(*this);
3585
3586    for (const auto& type : LEGACY_OUTPUT_TYPES) {
3587        m_internal_spk_managers[type] = spk_manager.get();
3588        m_external_spk_managers[type] = spk_manager.get();
3589    }
3590    uint256 id = spk_manager->GetID();
3591    AddScriptPubKeyMan(id, std::move(spk_manager));
3592}
3593
3594bool CWallet::WithEncryptionKey(std::function<bool (const CKeyingMaterial&)> cb) const
3595{
3596    LOCK(cs_wallet);
3597    return cb(vMasterKey);
3598}
3599
3600bool CWallet::HasEncryptionKeys() const
3601{
3602    return !mapMasterKeys.empty();
3603}
3604
3605bool CWallet::HaveCryptedKeys() const
3606{
3607    for (const auto& spkm : GetAllScriptPubKeyMans()) {
3608        if (spkm->HaveCryptedKeys()) return true;
3609    }
3610    return false;
3611}
3612
3613void CWallet::ConnectScriptPubKeyManNotifiers()
3614{
3615    for (const auto& spk_man : GetActiveScriptPubKeyMans()) {
3616        spk_man->NotifyCanGetAddressesChanged.connect([this] {
3617            NotifyCanGetAddressesChanged();
3618        });
3619        spk_man->NotifyFirstKeyTimeChanged.connect([this](const ScriptPubKeyMan*, int64_t time) {
3620            MaybeUpdateBirthTime(time);
3621        });
3622    }
3623}
3624
3625void CWallet::LoadDescriptorScriptPubKeyMan(uint256 id, WalletDescriptor& desc, const KeyMap& keys, const CryptedKeyMap& ckeys)
3626{
3627    std::unique_ptr<DescriptorScriptPubKeyMan> spk_manager;
3628    if (IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER)) {
3629        spk_manager = ExternalSignerScriptPubKeyMan::LoadFromStorage(*this, id, desc, m_keypool_size, keys, ckeys);
3630    } else {
3631        spk_manager = DescriptorScriptPubKeyMan::LoadFromStorage(*this, id, desc, m_keypool_size, keys, ckeys);
3632    }
3633    AddScriptPubKeyMan(id, std::move(spk_manager));
3634}
3635
3636DescriptorScriptPubKeyMan& CWallet::SetupDescriptorScriptPubKeyMan(WalletBatch& batch, const CExtKey& master_key, const OutputType& output_type, bool internal)
3637{
3638    AssertLockHeld(cs_wallet);
3639    if (IsLocked()) {
3640        throw std::runtime_error(std::string(__func__) + ": Wallet is locked, cannot setup new descriptors");
3641    }
3642    auto spk_manager = DescriptorScriptPubKeyMan::GenerateNewSingleSig(*this, batch, m_keypool_size, master_key, output_type, internal);
3643    DescriptorScriptPubKeyMan* out = spk_manager.get();
3644    uint256 id = spk_manager->GetID();
3645    AddScriptPubKeyMan(id, std::move(spk_manager));
3646    AddActiveScriptPubKeyManWithDb(batch, id, output_type, internal);
3647    return *out;
3648}
3649
3650void CWallet::SetupDescriptorScriptPubKeyMans(WalletBatch& batch, const CExtKey& master_key)
3651{
3652    AssertLockHeld(cs_wallet);
3653    for (bool internal : {false, true}) {
3654        for (OutputType t : OUTPUT_TYPES) {
3655            SetupDescriptorScriptPubKeyMan(batch, master_key, t, internal);
3656        }
3657    }
3658}
3659
3660void CWallet::SetupOwnDescriptorScriptPubKeyMans(WalletBatch& batch)
3661{
3662    AssertLockHeld(cs_wallet);
3663    assert(!IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER));
3664    // Make a seed
3665    CKey seed_key = GenerateRandomKey();
3666    CPubKey seed = seed_key.GetPubKey();
3667    assert(seed_key.VerifyPubKey(seed));
3668
3669    // Get the extended key
3670    CExtKey master_key;
3671    master_key.SetSeed(seed_key);
3672
3673    SetupDescriptorScriptPubKeyMans(batch, master_key);
3674}
3675
3676void CWallet::SetupDescriptorScriptPubKeyMans()
3677{
3678    AssertLockHeld(cs_wallet);
3679
3680    if (!IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER)) {
3681        if (!RunWithinTxn(GetDatabase(), /*process_desc=*/"setup descriptors", [&](WalletBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet){
3682            SetupOwnDescriptorScriptPubKeyMans(batch);
3683            return true;
3684        })) throw std::runtime_error("Error: cannot process db transaction for descriptors setup");
3685    } else {
3686        auto signer = ExternalSignerScriptPubKeyMan::GetExternalSigner();
3687        if (!signer) throw std::runtime_error(util::ErrorString(signer).original);
3688
3689        // TODO: add account parameter
3690        int account = 0;
3691        UniValue signer_res = signer->GetDescriptors(account);
3692
3693        if (!signer_res.isObject()) throw std::runtime_error(std::string(__func__) + ": Unexpected result");
3694
3695        WalletBatch batch(GetDatabase());
3696        if (!batch.TxnBegin()) throw std::runtime_error("Error: cannot create db transaction for descriptors import");
3697
3698        for (bool internal : {false, true}) {
3699            const UniValue& descriptor_vals = signer_res.find_value(internal ? "internal" : "receive");
3700            if (!descriptor_vals.isArray()) throw std::runtime_error(std::string(__func__) + ": Unexpected result");
3701            for (const UniValue& desc_val : descriptor_vals.get_array().getValues()) {
3702                const std::string& desc_str = desc_val.getValStr();
3703                FlatSigningProvider keys;
3704                std::string desc_error;
3705                auto descs = Parse(desc_str, keys, desc_error, false);
3706                if (descs.empty()) {
3707                    throw std::runtime_error(std::string(__func__) + ": Invalid descriptor \"" + desc_str + "\" (" + desc_error + ")");
3708                }
3709                auto& desc = descs.at(0);
3710                if (!desc->GetOutputType()) {
3711                    continue;
3712                }
3713                OutputType t =  *desc->GetOutputType();
3714                auto spk_manager = ExternalSignerScriptPubKeyMan::CreateNew(*this, batch, m_keypool_size, std::move(desc));
3715                uint256 id = spk_manager->GetID();
3716                AddScriptPubKeyMan(id, std::move(spk_manager));
3717                AddActiveScriptPubKeyManWithDb(batch, id, t, internal);
3718            }
3719        }
3720
3721        // Ensure imported descriptors are committed to disk
3722        if (!batch.TxnCommit()) throw std::runtime_error("Error: cannot commit db transaction for descriptors import");
3723    }
3724}
3725
3726void CWallet::SetupWalletGeneration()
3727{
3728    AssertLockHeld(cs_wallet);
3729    // Skip setup for non-external-signer wallets that are either blank
3730    // or have private keys disabled (not having private keys implies blank).
3731    if (!IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER) &&
3732        (IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET) || IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS))) {
3733        return;
3734    }
3735    SetupDescriptorScriptPubKeyMans();
3736}
3737
3738void CWallet::AddActiveScriptPubKeyMan(uint256 id, OutputType type, bool internal)
3739{
3740    WalletBatch batch(GetDatabase());
3741    return AddActiveScriptPubKeyManWithDb(batch, id, type, internal);
3742}
3743
3744void CWallet::AddActiveScriptPubKeyManWithDb(WalletBatch& batch, uint256 id, OutputType type, bool internal)
3745{
3746    if (!batch.WriteActiveScriptPubKeyMan(static_cast<uint8_t>(type), id, internal)) {
3747        throw std::runtime_error(std::string(__func__) + ": writing active ScriptPubKeyMan id failed");
3748    }
3749    LoadActiveScriptPubKeyMan(id, type, internal);
3750}