251                    // Since this entry will be erased,
252                    // we can move the coin into us instead of copying it
253                    itUs->second.coin = std::move(it->second.coin);
254                } else {
255                    itUs->second.coin = it->second.coin;
256                }
257                cachedCoinsUsage += itUs->second.coin.DynamicMemoryUsage();
258                if (!itUs->second.IsDirty()) {
259                    CCoinsCacheEntry::SetDirty(*itUs, m_sentinel);
260                    ++m_dirty_count;
261                }
262                // NOTE: It isn't safe to mark the coin as FRESH in the parent
263                // cache. If it already existed and was spent in the parent
264                // cache then marking it FRESH would prevent that spentness
265                // from being flushed to the grandparent.
266            }
267        }
268    }
269    SetBestBlock(in_block_hash);
270}
271
272void CCoinsViewCache::Flush(bool reallocate_cache)
273{
274    auto cursor{CoinsViewCacheCursor(m_dirty_count, m_sentinel, cacheCoins, /*will_erase=*/true)};
275    base->BatchWrite(cursor, m_block_hash);
276    Assume(m_dirty_count == 0);
277    cacheCoins.clear();
278    if (reallocate_cache) {
279        ReallocateCache();
280    }
281    cachedCoinsUsage = 0;
282}
283
284void CCoinsViewCache::Sync()
285{
286    auto cursor{CoinsViewCacheCursor(m_dirty_count, m_sentinel, cacheCoins, /*will_erase=*/false)};
287    base->BatchWrite(cursor, m_block_hash);
288    Assume(m_dirty_count == 0);
289    if (m_sentinel.second.Next() != &m_sentinel) {
290        /* BatchWrite must clear flags of all entries */
291        throw std::logic_error("Not all unspent flagged entries were cleared");
292    }
293}
294
295void CCoinsViewCache::Reset() noexcept
296{
297    cacheCoins.clear();
298    cachedCoinsUsage = 0;
299    m_dirty_count = 0;
300    SetBestBlock(uint256::ZERO);
301}
302
303void CCoinsViewCache::Uncache(const COutPoint& hash)
304{
305    CCoinsMap::iterator it = cacheCoins.find(hash);
306    if (it != cacheCoins.end() && !it->second.IsDirty()) {
307        Assume(TrySub(cachedCoinsUsage, it->second.coin.DynamicMemoryUsage()));
308        TRACEPOINT(utxocache, uncache,
309               hash.hash.data(),
310               (uint32_t)hash.n,
311               (uint32_t)it->second.coin.nHeight,
312               (int64_t)it->second.coin.out.nValue,
313               (bool)it->second.coin.IsCoinBase());
314        cacheCoins.erase(it);
315    }
316}
317
318unsigned int CCoinsViewCache::GetCacheSize() const {
319    return cacheCoins.size();
320}
321
322bool CCoinsViewCache::HaveInputs(const CTransaction& tx) const
323{
324    if (!tx.IsCoinBase()) {
325        for (unsigned int i = 0; i < tx.vin.size(); i++) {
326            if (!HaveCoin(tx.vin[i].prevout)) {
327                return false;
328            }
329        }
330    }
331    return true;
332}
333
334void CCoinsViewCache::ReallocateCache()
335{
336    // Cache should be empty when we're calling this.
337    assert(cacheCoins.size() == 0);
338    cacheCoins.~CCoinsMap();
339    m_cache_coins_memory_resource.~CCoinsMapMemoryResource();
340    ::new (&m_cache_coins_memory_resource) CCoinsMapMemoryResource{};
341    ::new (&cacheCoins) CCoinsMap{0, SaltedCoinsCacheHasher{/*deterministic=*/m_deterministic}, CCoinsMap::key_equal{}, &m_cache_coins_memory_resource};
342}
343
344void CCoinsViewCache::SanityCheck() const
345{
346    size_t recomputed_usage = 0;
347    size_t count_dirty = 0;
348    for (const auto& [_, entry] : cacheCoins) {
349        if (entry.coin.IsSpent()) {
350            assert(entry.IsDirty() && !entry.IsFresh()); // A spent coin must be dirty and cannot be fresh
351        } else {
352            assert(entry.IsDirty() || !entry.IsFresh()); // An unspent coin must not be fresh if not dirty
353        }
354
355        // Recompute cachedCoinsUsage.
356        recomputed_usage += entry.coin.DynamicMemoryUsage();
357
358        // Count the number of entries we expect in the linked list.
359        if (entry.IsDirty()) ++count_dirty;
360    }
361    // Iterate over the linked list of flagged entries.
362    size_t count_linked = 0;
363    for (auto it = m_sentinel.second.Next(); it != &m_sentinel; it = it->second.Next()) {
364        // Verify linked list integrity.
365        assert(it->second.Next()->second.Prev() == it);
366        assert(it->second.Prev()->second.Next() == it);
367        // Verify they are actually flagged.
368        assert(it->second.IsDirty());
369        // Count the number of entries actually in the list.
370        ++count_linked;
371    }
372    assert(count_dirty == count_linked && count_dirty == m_dirty_count);
373    assert(recomputed_usage == cachedCoinsUsage);
374}
375
376CCoinsViewCache::ResetGuard CoinsViewOverlay::StartFetching(const CBlock& block LIFETIMEBOUND) noexcept
377{
378    Assert(m_futures.empty());
379    Assert(m_inputs.empty());
380    Assert(m_input_head.load(std::memory_order_relaxed) == 0);
381    Assert(m_input_tail == 0);
382    if (const auto workers_count{m_thread_pool->WorkersCount()}; workers_count > 0 && block.vtx.size() > 1) {
383        // Loop through the block inputs and set their prevouts in the queue.
384        // Filter inputs that spend outputs created earlier in the same block. These outputs will be created
385        // directly in the cache from the tx that creates them, so they will not be requested from a base view.
386        std::unordered_set<Txid, SaltedCoinsCacheHasher> earlier_txids;
387        earlier_txids.reserve(block.vtx.size());
388        earlier_txids.emplace(block.vtx[0]->GetHash());
389        for (const auto& tx : block.vtx | std::views::drop(1)) {
390            for (const auto& input : tx->vin) {
391                if (!earlier_txids.contains(input.prevout.hash)) m_inputs.emplace_back(input.prevout);
392            }
393            earlier_txids.emplace(tx->GetHash());
394        }
395        // Only submit tasks if we have something to fetch.
396        if (m_inputs.size()) {
397            std::vector<std::function<void()>> tasks(workers_count, [this] {
398                while (ProcessInput()) {}
399            });
400            if (auto futures{m_thread_pool->Submit(std::move(tasks))}) {
401                m_futures = std::move(*futures);
402            } else {
403                // Submit can fail if a shared owner of the thread pool outside of this class calls Stop() or
404                // Interrupt() on a different thread after we call WorkersCount() above. In that case parallel
405                // fetching will not make progress, so we clear the inputs to fall back to single threaded fetching.
406                LogWarning("Failed to submit prevout fetch tasks (%s); falling back to single-threaded fetching for this block.", SubmitErrorString(futures.error()));
407                m_inputs.clear();
408                StopFetching(); // Assert nothing changed if we failed to start tasks.
409            }
410        }
411    }
412    return CreateResetGuard();
413}
414
415static const uint64_t MIN_TRANSACTION_OUTPUT_WEIGHT{WITNESS_SCALE_FACTOR * ::GetSerializeSize(CTxOut())};
416static const uint64_t MAX_OUTPUTS_PER_BLOCK{MAX_BLOCK_WEIGHT / MIN_TRANSACTION_OUTPUT_WEIGHT};
417
418const Coin& AccessByTxid(const CCoinsViewCache& view, const Txid& txid)
419{
420    COutPoint iter(txid, 0);
421    while (iter.n < MAX_OUTPUTS_PER_BLOCK) {
422        const Coin& alternate = view.AccessCoin(iter);
423        if (!alternate.IsSpent()) return alternate;
424        ++iter.n;
425    }
426    return coinEmpty;
427}
428
429template <typename ReturnType, typename Func>
430static ReturnType ExecuteBackedWrapper(Func func, const std::vector<std::function<void()>>& err_callbacks)
431{
432    try {
433        return func();
434    } catch(const std::runtime_error& e) {
435        for (const auto& f : err_callbacks) {
436            f();
437        }
438        LogError("Error reading from database: %s\n", e.what());
439        // Starting the shutdown sequence and returning false to the caller would be
440        // interpreted as 'entry not found' (as opposed to unable to read data), and
441        // could lead to invalid interpretation. Just exit immediately, as we can't
442        // continue anyway, and all writes should be atomic.
443        std::abort();
444    }
445}
446
447std::optional<Coin> CCoinsViewErrorCatcher::GetCoin(const COutPoint& outpoint) const
448{
449    return ExecuteBackedWrapper<std::optional<Coin>>([&]() { return CCoinsViewBacked::GetCoin(outpoint); }, m_err_callbacks);
450}
451
452bool CCoinsViewErrorCatcher::HaveCoin(const COutPoint& outpoint) const
453{
454    return ExecuteBackedWrapper<bool>([&]() { return CCoinsViewBacked::HaveCoin(outpoint); }, m_err_callbacks);
455}
456
457std::optional<Coin> CCoinsViewErrorCatcher::PeekCoin(const COutPoint& outpoint) const
458{
459    return ExecuteBackedWrapper<std::optional<Coin>>([&]() { return CCoinsViewBacked::PeekCoin(outpoint); }, m_err_callbacks);
460}
461