The wallet state and lifecycle

3751
3752void CWallet::LoadActiveScriptPubKeyMan(uint256 id, OutputType type, bool internal)
3753{
3754    // Activating ScriptPubKeyManager for a given output and change type is incompatible with legacy wallets.
3755    // Legacy wallets have only one ScriptPubKeyManager and it's active for all output and change types.
3756    Assert(IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
3757
3758    WalletLogPrintf("Setting spkMan to active: id = %s, type = %s, internal = %s\n", id.ToString(), FormatOutputType(type), internal ? "true" : "false");
3759    auto& spk_mans = internal ? m_internal_spk_managers : m_external_spk_managers;
3760    auto& spk_mans_other = internal ? m_external_spk_managers : m_internal_spk_managers;
3761    auto spk_man = m_spk_managers.at(id).get();
3762    spk_mans[type] = spk_man;
3763
3764    const auto it = spk_mans_other.find(type);
3765    if (it != spk_mans_other.end() && it->second == spk_man) {
3766        spk_mans_other.erase(type);
3767    }
3768
3769    NotifyCanGetAddressesChanged();
3770}
3771
3772void CWallet::DeactivateScriptPubKeyMan(uint256 id, OutputType type, bool internal)
3773{
3774    auto spk_man = GetScriptPubKeyMan(type, internal);
3775    if (spk_man != nullptr && spk_man->GetID() == id) {
3776        WalletLogPrintf("Deactivate spkMan: id = %s, type = %s, internal = %s\n", id.ToString(), FormatOutputType(type), internal ? "true" : "false");
3777        WalletBatch batch(GetDatabase());
3778        if (!batch.EraseActiveScriptPubKeyMan(static_cast<uint8_t>(type), internal)) {
3779            throw std::runtime_error(std::string(__func__) + ": erasing active ScriptPubKeyMan id failed");
3780        }
3781
3782        auto& spk_mans = internal ? m_internal_spk_managers : m_external_spk_managers;
3783        spk_mans.erase(type);
3784    }
3785
3786    NotifyCanGetAddressesChanged();
3787}
3788
3789DescriptorScriptPubKeyMan* CWallet::GetDescriptorScriptPubKeyMan(const WalletDescriptor& desc) const
3790{
3791    auto spk_man_pair = std::find_if(m_spk_managers.begin(), m_spk_managers.end(), [&desc](const auto& item) {
3792        DescriptorScriptPubKeyMan* spk_manager = dynamic_cast<DescriptorScriptPubKeyMan*>(item.second.get());
3793        return spk_manager != nullptr && spk_manager->HasWalletDescriptor(desc);
3794    });
3795
3796    if (spk_man_pair != m_spk_managers.end()) {
3797        return dynamic_cast<DescriptorScriptPubKeyMan*>(spk_man_pair->second.get());
3798    }
3799
3800    return nullptr;
3801}
3802
3803std::optional<bool> CWallet::IsInternalScriptPubKeyMan(ScriptPubKeyMan* spk_man) const
3804{
3805    // only active ScriptPubKeyMan can be internal
3806    if (!GetActiveScriptPubKeyMans().contains(spk_man)) {
3807        return std::nullopt;
3808    }
3809
3810    const auto desc_spk_man = dynamic_cast<DescriptorScriptPubKeyMan*>(spk_man);
3811    if (!desc_spk_man) {
3812        throw std::runtime_error(std::string(__func__) + ": unexpected ScriptPubKeyMan type.");
3813    }
3814
3815    LOCK(desc_spk_man->cs_desc_man);
3816    const auto& type = desc_spk_man->GetWalletDescriptor().descriptor->GetOutputType();
3817    assert(type.has_value());
3818
3819    return GetScriptPubKeyMan(*type, /* internal= */ true) == desc_spk_man;
3820}
3821
3822util::Result<std::reference_wrapper<DescriptorScriptPubKeyMan>> CWallet::AddWalletDescriptor(WalletDescriptor& desc, const FlatSigningProvider& signing_provider, const std::string& label, bool internal)
3823{
3824    AssertLockHeld(cs_wallet);
3825
3826    Assert(IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
3827
3828    auto spk_man = GetDescriptorScriptPubKeyMan(desc);
3829    if (spk_man) {
3830        WalletLogPrintf("Update existing descriptor: %s\n", desc.descriptor->ToString());
3831        if (auto spkm_res = spk_man->UpdateWalletDescriptor(desc, signing_provider); !spkm_res) {
3832            return util::Error{util::ErrorString(spkm_res)};
3833        }
3834    } else {
3835        auto new_spk_man = DescriptorScriptPubKeyMan::CreateFromImport(*this, desc, m_keypool_size, signing_provider);
3836        spk_man = new_spk_man.get();
3837
3838        // Save the descriptor to memory
3839        uint256 id = new_spk_man->GetID();
3840        AddScriptPubKeyMan(id, std::move(new_spk_man));
3841
3842        // Write the existing cache to disk
3843        WalletBatch batch(GetDatabase());
3844        if (!batch.WriteDescriptorCacheItems(id, desc.cache)) {
3845            return util::Error{_("Unable to write descriptor cache")};
3846        }
3847    }
3848
3849    // Apply the label if necessary
3850    // Note: we disable labels for descriptors that are ranged or that don't produce output scripts (i.e. unused())
3851    if (!desc.descriptor->IsRange() && desc.descriptor->HasScripts()) {
3852        auto script_pub_keys = spk_man->GetScriptPubKeys();
3853        if (script_pub_keys.empty()) {
3854            return util::Error{_("Could not generate scriptPubKeys (cache is empty)")};
3855        }
3856
3857        if (!internal) {
3858            for (const auto& script : script_pub_keys) {
3859                CTxDestination dest;
3860                if (ExtractDestination(script, dest)) {
3861                    SetAddressBook(dest, label, AddressPurpose::RECEIVE);
3862                }
3863            }
3864        }
3865    }
3866
3867    // Save the descriptor to DB
3868    spk_man->WriteDescriptor();
3869
3870    // Break balance caches so that outputs that are now IsMine in already known txs will be included in the balance
3871    MarkDirty();
3872
3873    return std::reference_wrapper(*spk_man);
3874}
3875
3876bool CWallet::MigrateToSQLite(bilingual_str& error)
3877{
3878    AssertLockHeld(cs_wallet);
3879
3880    WalletLogPrintf("Migrating wallet storage database from BerkeleyDB to SQLite.\n");
3881
3882    if (m_database->Format() == "sqlite") {
3883        error = _("Error: This wallet already uses SQLite");
3884        return false;
3885    }
3886
3887    // Get all of the records for DB type migration
3888    std::unique_ptr<DatabaseBatch> batch = m_database->MakeBatch();
3889    std::unique_ptr<DatabaseCursor> cursor = batch->GetNewCursor();
3890    std::vector<std::pair<SerializeData, SerializeData>> records;
3891    if (!cursor) {
3892        error = _("Error: Unable to begin reading all records in the database");
3893        return false;
3894    }
3895    DatabaseCursor::Status status = DatabaseCursor::Status::FAIL;
3896    while (true) {
3897        DataStream ss_key{};
3898        DataStream ss_value{};
3899        status = cursor->Next(ss_key, ss_value);
3900        if (status != DatabaseCursor::Status::MORE) {
3901            break;
3902        }
3903        SerializeData key(ss_key.begin(), ss_key.end());
3904        SerializeData value(ss_value.begin(), ss_value.end());
3905        records.emplace_back(key, value);
3906    }
3907    cursor.reset();
3908    batch.reset();
3909    if (status != DatabaseCursor::Status::DONE) {
3910        error = _("Error: Unable to read all records in the database");
3911        return false;
3912    }
3913
3914    // Close this database and delete the file
3915    fs::path db_path = fs::PathFromString(m_database->Filename());
3916    m_database->Close();
3917    fs::remove(db_path);
3918
3919    // Generate the path for the location of the migrated wallet
3920    // Wallets that are plain files rather than wallet directories will be migrated to be wallet directories.
3921    const fs::path wallet_path = fsbridge::AbsPathJoin(GetWalletDir(), fs::PathFromString(m_name));
3922
3923    // Make new DB
3924    DatabaseOptions opts;
3925    opts.require_create = true;
3926    opts.require_format = DatabaseFormat::SQLITE;
3927    DatabaseStatus db_status;
3928    std::unique_ptr<WalletDatabase> new_db = MakeDatabase(wallet_path, opts, db_status, error);
3929    assert(new_db); // This is to prevent doing anything further with this wallet. The original file was deleted, but a backup exists.
3930    m_database.reset();
3931    m_database = std::move(new_db);
3932
3933    // Write existing records into the new DB
3934    batch = m_database->MakeBatch();
3935    bool began = batch->TxnBegin();
3936    assert(began); // This is a critical error, the new db could not be written to. The original db exists as a backup, but we should not continue execution.
3937    for (const auto& [key, value] : records) {
3938        if (!batch->Write(std::span{key}, std::span{value})) {
3939            batch->TxnAbort();
3940            m_database->Close();
3941            fs::remove(m_database->Filename());
3942            assert(false); // This is a critical error, the new db could not be written to. The original db exists as a backup, but we should not continue execution.
3943        }
3944    }
3945    bool committed = batch->TxnCommit();
3946    assert(committed); // This is a critical error, the new db could not be written to. The original db exists as a backup, but we should not continue execution.
3947    return true;
3948}
3949
3950std::optional<MigrationData> CWallet::GetDescriptorsForLegacy(bilingual_str& error) const
3951{
3952    AssertLockHeld(cs_wallet);
3953
3954    LegacyDataSPKM* legacy_spkm = GetLegacyDataSPKM();
3955    if (!Assume(legacy_spkm)) {
3956        // This shouldn't happen
3957        error = Untranslated(STR_INTERNAL_BUG("Error: Legacy wallet data missing"));
3958        return std::nullopt;
3959    }
3960
3961    std::optional<MigrationData> res = legacy_spkm->MigrateToDescriptor();
3962    if (res == std::nullopt) {
3963        error = _("Error: Unable to produce descriptors for this legacy wallet. Make sure to provide the wallet's passphrase if it is encrypted.");
3964        return std::nullopt;
3965    }
3966    return res;
3967}
3968
3969util::Result<void> CWallet::ApplyMigrationData(WalletBatch& local_wallet_batch, MigrationData& data)
3970{
3971    AssertLockHeld(cs_wallet);
3972
3973    LegacyDataSPKM* legacy_spkm = GetLegacyDataSPKM();
3974    if (!Assume(legacy_spkm)) {
3975        // This shouldn't happen
3976        return util::Error{Untranslated(STR_INTERNAL_BUG("Error: Legacy wallet data missing"))};
3977    }
3978
3979    // Note: when the legacy wallet has no spendable scripts, it must be empty at the end of the process.
3980    bool has_spendable_material = !data.desc_spkms.empty() || data.master_key.key.IsValid();
3981
3982    // Get all invalid or non-watched scripts that will not be migrated
3983    std::set<CTxDestination> not_migrated_dests;
3984    for (const auto& script : legacy_spkm->GetNotMineScriptPubKeys()) {
3985        CTxDestination dest;
3986        if (ExtractDestination(script, dest)) not_migrated_dests.emplace(dest);
3987    }
3988
3989    // When the legacy wallet has no spendable scripts, the main wallet will be empty, leaving its script cache empty as well.
3990    // The watch-only and/or solvable wallet(s) will contain the scripts in their respective caches.
3991    if (!data.desc_spkms.empty()) Assume(!m_cached_spks.empty());
3992    if (!data.watch_descs.empty()) Assume(!data.watchonly_wallet->m_cached_spks.empty());
3993    if (!data.solvable_descs.empty()) Assume(!data.solvable_wallet->m_cached_spks.empty());
3994
3995    for (auto& desc_spkm : data.desc_spkms) {
3996        if (m_spk_managers.contains(desc_spkm->GetID())) {
3997            return util::Error{_("Error: Duplicate descriptors created during migration. Your wallet may be corrupted.")};
3998        }
3999        uint256 id = desc_spkm->GetID();
4000        AddScriptPubKeyMan(id, std::move(desc_spkm));