The wallet state and lifecycle

4001    }
4002
4003    // Remove the LegacyDataSPKM's records from disk
4004    if (!legacy_spkm->DeleteRecordsWithDB(local_wallet_batch)) {
4005        return util::Error{_("Error: cannot remove legacy wallet records")};
4006    }
4007
4008    // Remove the LegacyDataSPKM from memory
4009    m_spk_managers.erase(legacy_spkm->GetID());
4010    m_external_spk_managers.clear();
4011    m_internal_spk_managers.clear();
4012
4013    // Setup new descriptors (only if we are migrating any key material)
4014    SetWalletFlagWithDB(local_wallet_batch, WALLET_FLAG_DESCRIPTORS | WALLET_FLAG_LAST_HARDENED_XPUB_CACHED);
4015    if (has_spendable_material && !IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
4016        // Use the existing master key if we have it
4017        if (data.master_key.key.IsValid()) {
4018            SetupDescriptorScriptPubKeyMans(local_wallet_batch, data.master_key);
4019        } else {
4020            // Setup with a new seed if we don't.
4021            SetupOwnDescriptorScriptPubKeyMans(local_wallet_batch);
4022        }
4023    }
4024
4025    // Get best block locator so that we can copy it to the watchonly and solvables
4026    // Note: The best block locator was introduced in #152 so ancient wallets do not have it
4027    CBlockLocator best_block_locator;
4028    (void)local_wallet_batch.ReadBestBlock(best_block_locator);
4029
4030    // Update m_txos to match the descriptors remaining in this wallet
4031    m_txos.clear();
4032    RefreshAllTXOs();
4033
4034    // Check if the transactions in the wallet are still ours. Either they belong here, or they belong in the watchonly wallet.
4035    // We need to go through these in the tx insertion order so that lookups to spends works.
4036    std::vector<Txid> txids_to_delete;
4037    std::unique_ptr<WalletBatch> watchonly_batch;
4038    if (data.watchonly_wallet) {
4039        watchonly_batch = std::make_unique<WalletBatch>(data.watchonly_wallet->GetDatabase());
4040        if (!watchonly_batch->TxnBegin()) return util::Error{strprintf(_("Error: database transaction cannot be executed for wallet %s"), data.watchonly_wallet->GetName())};
4041        // Copy the next tx order pos to the watchonly wallet
4042        LOCK(data.watchonly_wallet->cs_wallet);
4043        data.watchonly_wallet->nOrderPosNext = nOrderPosNext;
4044        watchonly_batch->WriteOrderPosNext(data.watchonly_wallet->nOrderPosNext);
4045        // Write the locator record. An empty locator is valid and triggers rescan on load.
4046        if (!watchonly_batch->WriteBestBlock(best_block_locator)) {
4047            return util::Error{_("Error: Unable to write watchonly wallet best block locator record")};
4048        }
4049    }
4050    std::unique_ptr<WalletBatch> solvables_batch;
4051    if (data.solvable_wallet) {
4052        solvables_batch = std::make_unique<WalletBatch>(data.solvable_wallet->GetDatabase());
4053        if (!solvables_batch->TxnBegin()) return util::Error{strprintf(_("Error: database transaction cannot be executed for wallet %s"), data.solvable_wallet->GetName())};
4054        // Write the locator record. An empty locator is valid and triggers rescan on load.
4055        if (!solvables_batch->WriteBestBlock(best_block_locator)) {
4056            return util::Error{_("Error: Unable to write solvable wallet best block locator record")};
4057        }
4058    }
4059    for (const auto& [_pos, wtx] : wtxOrdered) {
4060        // Check it is the watchonly wallet's
4061        // solvable_wallet doesn't need to be checked because transactions for those scripts weren't being watched for
4062        bool is_mine = IsMine(*wtx->GetTx()) || IsFromMe(*wtx->GetTx());
4063        if (data.watchonly_wallet) {
4064            LOCK(data.watchonly_wallet->cs_wallet);
4065            if (data.watchonly_wallet->IsMine(*wtx->GetTx()) || data.watchonly_wallet->IsFromMe(*wtx->GetTx())) {
4066                // Add to watchonly wallet
4067                const Txid& hash = wtx->GetHash();
4068                DataStream wtx_ser;
4069                wtx_ser << *wtx;
4070                CWalletTx copy_wtx(deserialize, wtx_ser, wtx->GetTxs());
4071                if (!data.watchonly_wallet->LoadToWallet(std::move(copy_wtx))) {
4072                    return util::Error{strprintf(_("Error: Could not add watchonly tx %s to watchonly wallet"), wtx->GetHash().GetHex())};
4073                }
4074                watchonly_batch->WriteFullTx(data.watchonly_wallet->mapWallet.at(hash));
4075                // Mark as to remove from the migrated wallet only if it does not also belong to it
4076                if (!is_mine) {
4077                    txids_to_delete.push_back(hash);
4078                    continue;
4079                }
4080            }
4081        }
4082        if (!is_mine) {
4083            // Both not ours and not in the watchonly wallet
4084            return util::Error{strprintf(_("Error: Transaction %s in wallet cannot be identified to belong to migrated wallets"), wtx->GetHash().GetHex())};
4085        }
4086        // Rewrite the transaction so that anything that may have changed about it in memory also persists to disk
4087        local_wallet_batch.WriteTxMetadata(*wtx);
4088    }
4089
4090    // Do the removes
4091    if (txids_to_delete.size() > 0) {
4092        if (auto res = RemoveTxs(local_wallet_batch, txids_to_delete); !res) {
4093            return util::Error{_("Error: Could not delete watchonly transactions. ") + util::ErrorString(res)};
4094        }
4095    }
4096
4097    // Pair external wallets with their corresponding db handler
4098    std::vector<std::pair<std::shared_ptr<CWallet>, std::unique_ptr<WalletBatch>>> wallets_vec;
4099    if (data.watchonly_wallet) wallets_vec.emplace_back(data.watchonly_wallet, std::move(watchonly_batch));
4100    if (data.solvable_wallet) wallets_vec.emplace_back(data.solvable_wallet, std::move(solvables_batch));
4101
4102    // Write address book entry to disk
4103    auto func_store_addr = [](WalletBatch& batch, const CTxDestination& dest, const CAddressBookData& entry) {
4104        auto address{EncodeDestination(dest)};
4105        if (entry.purpose) batch.WritePurpose(address, PurposeToString(*entry.purpose));
4106        if (entry.label) batch.WriteName(address, *entry.label);
4107        for (const auto& [id, request] : entry.receive_requests) {
4108            batch.WriteAddressReceiveRequest(dest, id, request);
4109        }
4110        if (entry.previously_spent) batch.WriteAddressPreviouslySpent(dest, true);
4111    };
4112
4113    // Check the address book data in the same way we did for transactions
4114    std::vector<CTxDestination> dests_to_delete;
4115    for (const auto& [dest, record] : m_address_book) {
4116        // Ensure "receive" entries that are no longer part of the original wallet are transferred to another wallet
4117        // Entries for everything else ("send") will be cloned to all wallets.
4118        bool require_transfer = record.purpose == AddressPurpose::RECEIVE && !IsMine(dest);
4119        bool copied = false;
4120        for (auto& [wallet, batch] : wallets_vec) {
4121            LOCK(wallet->cs_wallet);
4122            if (require_transfer && !wallet->IsMine(dest)) continue;
4123
4124            // Copy the entire address book entry
4125            wallet->m_address_book[dest] = record;
4126            func_store_addr(*batch, dest, record);
4127
4128            copied = true;
4129            // Only delete 'receive' records that are no longer part of the original wallet
4130            if (require_transfer) {
4131                dests_to_delete.push_back(dest);
4132                break;
4133            }
4134        }
4135
4136        // Fail immediately if we ever found an entry that was ours and cannot be transferred
4137        // to any of the created wallets (watch-only, solvable).
4138        // Means that no inferred descriptor maps to the stored entry. Which mustn't happen.
4139        if (require_transfer && !copied) {
4140
4141            // Skip invalid/non-watched scripts that will not be migrated
4142            if (not_migrated_dests.contains(dest)) {
4143                dests_to_delete.push_back(dest);
4144                continue;
4145            }
4146
4147            return util::Error{_("Error: Address book data in wallet cannot be identified to belong to migrated wallets")};
4148        }
4149    }
4150
4151    // Persist external wallets address book entries
4152    for (auto& [wallet, batch] : wallets_vec) {
4153        if (!batch->TxnCommit()) {
4154            return util::Error{strprintf(_("Error: Unable to write data to disk for wallet %s"), wallet->GetName())};
4155        }
4156    }
4157
4158    // Remove the things to delete in this wallet
4159    if (dests_to_delete.size() > 0) {
4160        for (const auto& dest : dests_to_delete) {
4161            if (!DelAddressBookWithDB(local_wallet_batch, dest)) {
4162                return util::Error{_("Error: Unable to remove watchonly address book data")};
4163            }
4164        }
4165    }
4166
4167    // If there was no key material in the main wallet, there should be no records on it anymore.
4168    // This wallet will be discarded at the end of the process. Only wallets that contain the
4169    // migrated records will be presented to the user.
4170    if (!has_spendable_material) {
4171        if (!m_address_book.empty()) return util::Error{_("Error: Not all address book records were migrated")};
4172        if (!mapWallet.empty()) return util::Error{_("Error: Not all transaction records were migrated")};
4173    }
4174
4175    return {}; // all good
4176}
4177
4178bool CWallet::CanGrindR() const
4179{
4180    return !IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
4181}
4182
4183// Returns wallet prefix for migration.
4184// Used to name the backup file and newly created wallets.
4185// E.g. a watch-only wallet is named "<prefix>_watchonly".
4186static std::string MigrationPrefixName(CWallet& wallet)
4187{
4188    const std::string& name{wallet.GetName()};
4189    return name.empty() ? "default_wallet" : name;
4190}
4191
4192bool DoMigration(CWallet& wallet, WalletContext& context, bilingual_str& error, MigrationResult& res, const bool load_on_startup = true) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
4193{
4194    AssertLockHeld(wallet.cs_wallet);
4195
4196    // Get all of the descriptors from the legacy wallet
4197    std::optional<MigrationData> data = wallet.GetDescriptorsForLegacy(error);
4198    if (data == std::nullopt) return false;
4199
4200    // Create the watchonly and solvable wallets if necessary
4201    if (data->watch_descs.size() > 0 || data->solvable_descs.size() > 0) {
4202        DatabaseOptions options;
4203        options.require_existing = false;
4204        options.require_create = true;
4205        options.require_format = DatabaseFormat::SQLITE;
4206
4207        WalletContext empty_context;
4208        empty_context.args = context.args;
4209
4210        // Make the wallets
4211        options.create_flags = WALLET_FLAG_DISABLE_PRIVATE_KEYS | WALLET_FLAG_BLANK_WALLET | WALLET_FLAG_DESCRIPTORS;
4212        if (wallet.IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE)) {
4213            options.create_flags |= WALLET_FLAG_AVOID_REUSE;
4214        }
4215        if (wallet.IsWalletFlagSet(WALLET_FLAG_KEY_ORIGIN_METADATA)) {
4216            options.create_flags |= WALLET_FLAG_KEY_ORIGIN_METADATA;
4217        }
4218        if (data->watch_descs.size() > 0) {
4219            wallet.WalletLogPrintf("Making a new watchonly wallet containing the watched scripts\n");
4220
4221            DatabaseStatus status;
4222            std::vector<bilingual_str> warnings;
4223            std::string wallet_name = MigrationPrefixName(wallet) + "_watchonly";
4224            std::unique_ptr<WalletDatabase> database = MakeWalletDatabase(wallet_name, options, status, error);
4225            if (!database) {
4226                error = strprintf(_("Wallet file creation failed: %s"), error);
4227                return false;
4228            }
4229
4230            data->watchonly_wallet = CWallet::CreateNew(empty_context, wallet_name, std::move(database), options.create_flags, /*born_encrypted=*/false, error, warnings);
4231            if (!data->watchonly_wallet) {
4232                error = _("Error: Failed to create new watchonly wallet");
4233                return false;
4234            }
4235            res.watchonly_wallet = data->watchonly_wallet;
4236            LOCK(data->watchonly_wallet->cs_wallet);
4237
4238            // Parse the descriptors and add them to the new wallet
4239            for (const auto& [desc_str, creation_time] : data->watch_descs) {
4240                // Parse the descriptor
4241                FlatSigningProvider keys;
4242                std::string parse_err;
4243                std::vector<std::unique_ptr<Descriptor>> descs = Parse(desc_str, keys, parse_err, /*require_checksum=*/ true);
4244                // LegacyDataSPKM should not produce invalid, multipath, or ranged watch-only descriptors.
4245                assert(descs.size() == 1);
4246                assert(!descs.at(0)->IsRange());
4247
4248                // Add to the wallet
4249                WalletDescriptor w_desc(std::move(descs.at(0)), creation_time, 0, 0, 0);
4250                if (auto spkm_res = data->watchonly_wallet->AddWalletDescriptor(w_desc, keys, "", false); !spkm_res) {