/workdir/bitcoin/src/coins.cpp

Source (jump to first uncovered line)
// Copyright (c) 2012-2022 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <coins.h>

#include <consensus/consensus.h>
#include <logging.h>
#include <random.h>
#include <util/trace.h>

bool CCoinsView::GetCoin(const COutPoint &outpoint, Coin &coin) const { return false; }
uint256 CCoinsView::GetBestBlock() const { return uint256(); }
std::vector<uint256> CCoinsView::GetHeadBlocks() const { return std::vector<uint256>(); }
bool CCoinsView::BatchWrite(CoinsViewCacheCursor& cursor, const uint256 &hashBlock) { return false; }
std::unique_ptr<CCoinsViewCursor> CCoinsView::Cursor() const { return nullptr; }

bool CCoinsView::HaveCoin(const COutPoint &outpoint) const
{
    Coin coin;
    return GetCoin(outpoint, coin);
}

CCoinsViewBacked::CCoinsViewBacked(CCoinsView *viewIn) : base(viewIn) { }
bool CCoinsViewBacked::GetCoin(const COutPoint &outpoint, Coin &coin) const { return base->GetCoin(outpoint, coin); }
bool CCoinsViewBacked::HaveCoin(const COutPoint &outpoint) const { return base->HaveCoin(outpoint); }
uint256 CCoinsViewBacked::GetBestBlock() const { return base->GetBestBlock(); }
std::vector<uint256> CCoinsViewBacked::GetHeadBlocks() const { return base->GetHeadBlocks(); }
void CCoinsViewBacked::SetBackend(CCoinsView &viewIn) { base = &viewIn; }
bool CCoinsViewBacked::BatchWrite(CoinsViewCacheCursor& cursor, const uint256 &hashBlock) { return base->BatchWrite(cursor, hashBlock); }
std::unique_ptr<CCoinsViewCursor> CCoinsViewBacked::Cursor() const { return base->Cursor(); }
size_t CCoinsViewBacked::EstimateSize() const { return base->EstimateSize(); }

CCoinsViewCache::CCoinsViewCache(CCoinsView* baseIn, bool deterministic) :
    CCoinsViewBacked(baseIn), m_deterministic(deterministic),
    cacheCoins(0, SaltedOutpointHasher(/*deterministic=*/deterministic), CCoinsMap::key_equal{}, &m_cache_coins_memory_resource)
{
    m_sentinel.second.SelfRef(m_sentinel);
}

size_t CCoinsViewCache::DynamicMemoryUsage() const {
    return memusage::DynamicUsage(cacheCoins) + cachedCoinsUsage;
}

CCoinsMap::iterator CCoinsViewCache::FetchCoin(const COutPoint &outpoint) const {
    const auto [ret, inserted] = cacheCoins.try_emplace(outpoint);
    if (inserted) {
        if (!base->GetCoin(outpoint, ret->second.coin)) {
            cacheCoins.erase(ret);
            return cacheCoins.end();
        }
        if (ret->second.coin.IsSpent()) {
            // The parent only has an empty entry for this outpoint; we can consider our version as fresh.
            ret->second.AddFlags(CCoinsCacheEntry::FRESH, *ret, m_sentinel);
        }
        cachedCoinsUsage += ret->second.coin.DynamicMemoryUsage();
    }
    return ret;
}

bool CCoinsViewCache::GetCoin(const COutPoint &outpoint, Coin &coin) const {
    CCoinsMap::const_iterator it = FetchCoin(outpoint);
    if (it != cacheCoins.end()) {
        coin = it->second.coin;
        return !coin.IsSpent();
    }
    return false;
}

void CCoinsViewCache::AddCoin(const COutPoint &outpoint, Coin&& coin, bool possible_overwrite) {
    assert(!coin.IsSpent());
    if (coin.out.scriptPubKey.IsUnspendable()) return;
    CCoinsMap::iterator it;
    bool inserted;
    std::tie(it, inserted) = cacheCoins.emplace(std::piecewise_construct, std::forward_as_tuple(outpoint), std::tuple<>());
    bool fresh = false;
    if (!inserted) {
        cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
    }
    if (!possible_overwrite) {
        if (!it->second.coin.IsSpent()) {
            throw std::logic_error("Attempted to overwrite an unspent coin (when possible_overwrite is false)");
        }
        // If the coin exists in this cache as a spent coin and is DIRTY, then
        // its spentness hasn't been flushed to the parent cache. We're
        // re-adding the coin to this cache now but we can't mark it as FRESH.
        // If we mark it FRESH and then spend it before the cache is flushed
        // we would remove it from this cache and would never flush spentness
        // to the parent cache.
        //
        // Re-adding a spent coin can happen in the case of a re-org (the coin
        // is 'spent' when the block adding it is disconnected and then
        // re-added when it is also added in a newly connected block).
        //
        // If the coin doesn't exist in the current cache, or is spent but not
        // DIRTY, then it can be marked FRESH.
        fresh = !it->second.IsDirty();
    }
    it->second.coin = std::move(coin);
    it->second.AddFlags(CCoinsCacheEntry::DIRTY | (fresh ? CCoinsCacheEntry::FRESH : 0), *it, m_sentinel);
    cachedCoinsUsage += it->second.coin.DynamicMemoryUsage();
    TRACE5(utxocache, add,
           outpoint.hash.data(),
           (uint32_t)outpoint.n,
           (uint32_t)it->second.coin.nHeight,
           (int64_t)it->second.coin.out.nValue,
           (bool)it->second.coin.IsCoinBase());
}

void CCoinsViewCache::EmplaceCoinInternalDANGER(COutPoint&& outpoint, Coin&& coin) {
    cachedCoinsUsage += coin.DynamicMemoryUsage();
    auto [it, inserted] = cacheCoins.emplace(
        std::piecewise_construct,
        std::forward_as_tuple(std::move(outpoint)),
        std::forward_as_tuple(std::move(coin)));
    if (inserted) {
        it->second.AddFlags(CCoinsCacheEntry::DIRTY, *it, m_sentinel);
    }
}

void AddCoins(CCoinsViewCache& cache, const CTransaction &tx, int nHeight, bool check_for_overwrite) {
    bool fCoinbase = tx.IsCoinBase();
    const Txid& txid = tx.GetHash();
    for (size_t i = 0; i < tx.vout.size(); ++i) {
        bool overwrite = check_for_overwrite ? cache.HaveCoin(COutPoint(txid, i)) : fCoinbase;
        // Coinbase transactions can always be overwritten, in order to correctly
        // deal with the pre-BIP30 occurrences of duplicate coinbase transactions.
        cache.AddCoin(COutPoint(txid, i), Coin(tx.vout[i], nHeight, fCoinbase), overwrite);
    }
}

bool CCoinsViewCache::SpendCoin(const COutPoint &outpoint, Coin* moveout) {
    CCoinsMap::iterator it = FetchCoin(outpoint);
    if (it == cacheCoins.end()) return false;
    cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
    TRACE5(utxocache, spent,
           outpoint.hash.data(),
           (uint32_t)outpoint.n,
           (uint32_t)it->second.coin.nHeight,
           (int64_t)it->second.coin.out.nValue,
           (bool)it->second.coin.IsCoinBase());
    if (moveout) {
        *moveout = std::move(it->second.coin);
    }
    if (it->second.IsFresh()) {
        cacheCoins.erase(it);
    } else {
        it->second.AddFlags(CCoinsCacheEntry::DIRTY, *it, m_sentinel);
        it->second.coin.Clear();
    }
    return true;
}

static const Coin coinEmpty;

const Coin& CCoinsViewCache::AccessCoin(const COutPoint &outpoint) const {
    CCoinsMap::const_iterator it = FetchCoin(outpoint);
    if (it == cacheCoins.end()) {
        return coinEmpty;
    } else {
        return it->second.coin;
    }
}

bool CCoinsViewCache::HaveCoin(const COutPoint &outpoint) const {
    CCoinsMap::const_iterator it = FetchCoin(outpoint);
    return (it != cacheCoins.end() && !it->second.coin.IsSpent());
}

bool CCoinsViewCache::HaveCoinInCache(const COutPoint &outpoint) const {
    CCoinsMap::const_iterator it = cacheCoins.find(outpoint);
    return (it != cacheCoins.end() && !it->second.coin.IsSpent());
}

uint256 CCoinsViewCache::GetBestBlock() const {
    if (hashBlock.IsNull())
        hashBlock = base->GetBestBlock();
    return hashBlock;
}

void CCoinsViewCache::SetBestBlock(const uint256 &hashBlockIn) {
    hashBlock = hashBlockIn;
}

bool CCoinsViewCache::BatchWrite(CoinsViewCacheCursor& cursor, const uint256 &hashBlockIn) {
    for (auto it{cursor.Begin()}; it != cursor.End(); it = cursor.NextAndMaybeErase(*it)) {
        // Ignore non-dirty entries (optimization).
        if (!it->second.IsDirty()) {
            continue;
        }
        CCoinsMap::iterator itUs = cacheCoins.find(it->first);
        if (itUs == cacheCoins.end()) {
            // The parent cache does not have an entry, while the child cache does.
            // We can ignore it if it's both spent and FRESH in the child
            if (!(it->second.IsFresh() && it->second.coin.IsSpent())) {
                // Create the coin in the parent cache, move the data up
                // and mark it as dirty.
                itUs = cacheCoins.try_emplace(it->first).first;
                CCoinsCacheEntry& entry{itUs->second};
                if (cursor.WillErase(*it)) {
                    // Since this entry will be erased,
                    // we can move the coin into us instead of copying it
                    entry.coin = std::move(it->second.coin);
                } else {
                    entry.coin = it->second.coin;
                }
                cachedCoinsUsage += entry.coin.DynamicMemoryUsage();
                entry.AddFlags(CCoinsCacheEntry::DIRTY, *itUs, m_sentinel);
                // We can mark it FRESH in the parent if it was FRESH in the child
                // Otherwise it might have just been flushed from the parent's cache
                // and already exist in the grandparent
                if (it->second.IsFresh()) {
                    entry.AddFlags(CCoinsCacheEntry::FRESH, *itUs, m_sentinel);
                }
            }
        } else {
            // Found the entry in the parent cache
            if (it->second.IsFresh() && !itUs->second.coin.IsSpent()) {
                // The coin was marked FRESH in the child cache, but the coin
                // exists in the parent cache. If this ever happens, it means
                // the FRESH flag was misapplied and there is a logic error in
                // the calling code.
                throw std::logic_error("FRESH flag misapplied to coin that exists in parent cache");
            }

            if (itUs->second.IsFresh() && it->second.coin.IsSpent()) {
                // The grandparent cache does not have an entry, and the coin
                // has been spent. We can just delete it from the parent cache.
                cachedCoinsUsage -= itUs->second.coin.DynamicMemoryUsage();
                cacheCoins.erase(itUs);
            } else {
                // A normal modification.
                cachedCoinsUsage -= itUs->second.coin.DynamicMemoryUsage();
                if (cursor.WillErase(*it)) {
                    // Since this entry will be erased,
                    // we can move the coin into us instead of copying it
                    itUs->second.coin = std::move(it->second.coin);
                } else {
                    itUs->second.coin = it->second.coin;
                }
                cachedCoinsUsage += itUs->second.coin.DynamicMemoryUsage();
                itUs->second.AddFlags(CCoinsCacheEntry::DIRTY, *itUs, m_sentinel);
                // NOTE: It isn't safe to mark the coin as FRESH in the parent
                // cache. If it already existed and was spent in the parent
                // cache then marking it FRESH would prevent that spentness
                // from being flushed to the grandparent.
            }
        }
    }
    hashBlock = hashBlockIn;
    return true;
}

bool CCoinsViewCache::Flush() {
    auto cursor{CoinsViewCacheCursor(cachedCoinsUsage, m_sentinel, cacheCoins, /*will_erase=*/true)};
    bool fOk = base->BatchWrite(cursor, hashBlock);
    if (fOk) {
        cacheCoins.clear();
        ReallocateCache();
    }
    cachedCoinsUsage = 0;
    return fOk;
}

bool CCoinsViewCache::Sync()
{
    auto cursor{CoinsViewCacheCursor(cachedCoinsUsage, m_sentinel, cacheCoins, /*will_erase=*/false)};
    bool fOk = base->BatchWrite(cursor, hashBlock);
    if (fOk) {
        if (m_sentinel.second.Next() != &m_sentinel) {
            /* BatchWrite must clear flags of all entries */
            throw std::logic_error("Not all unspent flagged entries were cleared");
        }
    }
    return fOk;
}

void CCoinsViewCache::Uncache(const COutPoint& hash)
{
    CCoinsMap::iterator it = cacheCoins.find(hash);
    if (it != cacheCoins.end() && !it->second.IsDirty() && !it->second.IsFresh()) {
        cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
        TRACE5(utxocache, uncache,
               hash.hash.data(),
               (uint32_t)hash.n,
               (uint32_t)it->second.coin.nHeight,
               (int64_t)it->second.coin.out.nValue,
               (bool)it->second.coin.IsCoinBase());
        cacheCoins.erase(it);
    }
}

unsigned int CCoinsViewCache::GetCacheSize() const {
    return cacheCoins.size();
}

bool CCoinsViewCache::HaveInputs(const CTransaction& tx) const
{
    if (!tx.IsCoinBase()) {
        for (unsigned int i = 0; i < tx.vin.size(); i++) {
            if (!HaveCoin(tx.vin[i].prevout)) {
                return false;
            }
        }
    }
    return true;
}

void CCoinsViewCache::ReallocateCache()
{
    // Cache should be empty when we're calling this.
    assert(cacheCoins.size() == 0);
    cacheCoins.~CCoinsMap();
    m_cache_coins_memory_resource.~CCoinsMapMemoryResource();
    ::new (&m_cache_coins_memory_resource) CCoinsMapMemoryResource{};
    ::new (&cacheCoins) CCoinsMap{0, SaltedOutpointHasher{/*deterministic=*/m_deterministic}, CCoinsMap::key_equal{}, &m_cache_coins_memory_resource};
}

void CCoinsViewCache::SanityCheck() const
{
    size_t recomputed_usage = 0;
    size_t count_flagged = 0;
    for (const auto& [_, entry] : cacheCoins) {
        unsigned attr = 0;
        if (entry.IsDirty()) attr |= 1;
        if (entry.IsFresh()) attr |= 2;
        if (entry.coin.IsSpent()) attr |= 4;
        // Only 5 combinations are possible.
        assert(attr != 2 && attr != 4 && attr != 7);

        // Recompute cachedCoinsUsage.
        recomputed_usage += entry.coin.DynamicMemoryUsage();

        // Count the number of entries we expect in the linked list.
        if (entry.IsDirty() || entry.IsFresh()) ++count_flagged;
    }
    // Iterate over the linked list of flagged entries.
    size_t count_linked = 0;
    for (auto it = m_sentinel.second.Next(); it != &m_sentinel; it = it->second.Next()) {
        // Verify linked list integrity.
        assert(it->second.Next()->second.Prev() == it);
        assert(it->second.Prev()->second.Next() == it);
        // Verify they are actually flagged.
        assert(it->second.IsDirty() || it->second.IsFresh());
        // Count the number of entries actually in the list.
        ++count_linked;
    }
    assert(count_linked == count_flagged);
    assert(recomputed_usage == cachedCoinsUsage);
}

static const size_t MIN_TRANSACTION_OUTPUT_WEIGHT = WITNESS_SCALE_FACTOR * ::GetSerializeSize(CTxOut());
static const size_t MAX_OUTPUTS_PER_BLOCK = MAX_BLOCK_WEIGHT / MIN_TRANSACTION_OUTPUT_WEIGHT;

const Coin& AccessByTxid(const CCoinsViewCache& view, const Txid& txid)
{
    COutPoint iter(txid, 0);
    while (iter.n < MAX_OUTPUTS_PER_BLOCK) {
        const Coin& alternate = view.AccessCoin(iter);
        if (!alternate.IsSpent()) return alternate;
        ++iter.n;
    }
    return coinEmpty;
}

template <typename Func>
static bool ExecuteBackedWrapper(Func func, const std::vector<std::function<void()>>& err_callbacks)
{
    try {
        return func();
    } catch(const std::runtime_error& e) {
        for (const auto& f : err_callbacks) {
            f();
        }
        LogError("Error reading from database: %s\n", e.what());
        // Starting the shutdown sequence and returning false to the caller would be
        // interpreted as 'entry not found' (as opposed to unable to read data), and
        // could lead to invalid interpretation. Just exit immediately, as we can't
        // continue anyway, and all writes should be atomic.
        std::abort();
    }
}

bool CCoinsViewErrorCatcher::GetCoin(const COutPoint &outpoint, Coin &coin) const {
    return ExecuteBackedWrapper([&]() { return CCoinsViewBacked::GetCoin(outpoint, coin); }, m_err_callbacks);
}

bool CCoinsViewErrorCatcher::HaveCoin(const COutPoint &outpoint) const {
    return ExecuteBackedWrapper([&]() { return CCoinsViewBacked::HaveCoin(outpoint); }, m_err_callbacks);
}

Coverage Report

Created: 2024-08-21 05:08

Line	Count	Source (jump to first uncovered line)
1		// Copyright (c) 2012-2022 The Bitcoin Core developers
2		// Distributed under the MIT software license, see the accompanying
3		// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5		#include <coins.h>
6
7		#include <consensus/consensus.h>
8		#include <logging.h>
9		#include <random.h>
10		#include <util/trace.h>
11
12	0	bool CCoinsView::GetCoin(const COutPoint &outpoint, Coin &coin) const { return false; }
13	0	uint256 CCoinsView::GetBestBlock() const { return uint256(); }
14	0	std::vector<uint256> CCoinsView::GetHeadBlocks() const { return std::vector<uint256>(); }
15	0	bool CCoinsView::BatchWrite(CoinsViewCacheCursor& cursor, const uint256 &hashBlock) { return false; }
16	0	std::unique_ptr<CCoinsViewCursor> CCoinsView::Cursor() const { return nullptr; }
17
18		bool CCoinsView::HaveCoin(const COutPoint &outpoint) const
19	0	{
20	0	Coin coin;
21	0	return GetCoin(outpoint, coin);
22	0	}
23
24	0	CCoinsViewBacked::CCoinsViewBacked(CCoinsView *viewIn) : base(viewIn) { }
25	0	bool CCoinsViewBacked::GetCoin(const COutPoint &outpoint, Coin &coin) const { return base->GetCoin(outpoint, coin); }
26	0	bool CCoinsViewBacked::HaveCoin(const COutPoint &outpoint) const { return base->HaveCoin(outpoint); }
27	0	uint256 CCoinsViewBacked::GetBestBlock() const { return base->GetBestBlock(); }
28	0	std::vector<uint256> CCoinsViewBacked::GetHeadBlocks() const { return base->GetHeadBlocks(); }
29	0	void CCoinsViewBacked::SetBackend(CCoinsView &viewIn) { base = &viewIn; }
30	0	bool CCoinsViewBacked::BatchWrite(CoinsViewCacheCursor& cursor, const uint256 &hashBlock) { return base->BatchWrite(cursor, hashBlock); }
31	0	std::unique_ptr<CCoinsViewCursor> CCoinsViewBacked::Cursor() const { return base->Cursor(); }
32	0	size_t CCoinsViewBacked::EstimateSize() const { return base->EstimateSize(); }
33
34		CCoinsViewCache::CCoinsViewCache(CCoinsView* baseIn, bool deterministic) :
35	0	CCoinsViewBacked(baseIn), m_deterministic(deterministic),
36	0	cacheCoins(0, SaltedOutpointHasher(/deterministic=/deterministic), CCoinsMap::key_equal{}, &m_cache_coins_memory_resource)
37	0	{
38	0	m_sentinel.second.SelfRef(m_sentinel);
39	0	}
40
41	0	size_t CCoinsViewCache::DynamicMemoryUsage() const {
42	0	return memusage::DynamicUsage(cacheCoins) + cachedCoinsUsage;
43	0	}
44
45	0	CCoinsMap::iterator CCoinsViewCache::FetchCoin(const COutPoint &outpoint) const {
46	0	const auto [ret, inserted] = cacheCoins.try_emplace(outpoint);
47	0	if (inserted) { Branch (47:9): [True: 0, False: 0]
48	0	if (!base->GetCoin(outpoint, ret->second.coin)) { Branch (48:13): [True: 0, False: 0]
49	0	cacheCoins.erase(ret);
50	0	return cacheCoins.end();
51	0	}
52	0	if (ret->second.coin.IsSpent()) { Branch (52:13): [True: 0, False: 0]
53		// The parent only has an empty entry for this outpoint; we can consider our version as fresh.
54	0	ret->second.AddFlags(CCoinsCacheEntry::FRESH, *ret, m_sentinel);
55	0	}
56	0	cachedCoinsUsage += ret->second.coin.DynamicMemoryUsage();
57	0	}
58	0	return ret;
59	0	}
60
61	0	bool CCoinsViewCache::GetCoin(const COutPoint &outpoint, Coin &coin) const {
62	0	CCoinsMap::const_iterator it = FetchCoin(outpoint);
63	0	if (it != cacheCoins.end()) { Branch (63:9): [True: 0, False: 0]
64	0	coin = it->second.coin;
65	0	return !coin.IsSpent();
66	0	}
67	0	return false;
68	0	}
69
70	0	void CCoinsViewCache::AddCoin(const COutPoint &outpoint, Coin&& coin, bool possible_overwrite) {
71	0	assert(!coin.IsSpent());
72	0	if (coin.out.scriptPubKey.IsUnspendable()) return; Branch (72:9): [True: 0, False: 0]
73	0	CCoinsMap::iterator it;
74	0	bool inserted;
75	0	std::tie(it, inserted) = cacheCoins.emplace(std::piecewise_construct, std::forward_as_tuple(outpoint), std::tuple<>());
76	0	bool fresh = false;
77	0	if (!inserted) { Branch (77:9): [True: 0, False: 0]
78	0	cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
79	0	}
80	0	if (!possible_overwrite) { Branch (80:9): [True: 0, False: 0]
81	0	if (!it->second.coin.IsSpent()) { Branch (81:13): [True: 0, False: 0]
82	0	throw std::logic_error("Attempted to overwrite an unspent coin (when possible_overwrite is false)");
83	0	}
84		// If the coin exists in this cache as a spent coin and is DIRTY, then
85		// its spentness hasn't been flushed to the parent cache. We're
86		// re-adding the coin to this cache now but we can't mark it as FRESH.
87		// If we mark it FRESH and then spend it before the cache is flushed
88		// we would remove it from this cache and would never flush spentness
89		// to the parent cache.
90		//
91		// Re-adding a spent coin can happen in the case of a re-org (the coin
92		// is 'spent' when the block adding it is disconnected and then
93		// re-added when it is also added in a newly connected block).
94		//
95		// If the coin doesn't exist in the current cache, or is spent but not
96		// DIRTY, then it can be marked FRESH.
97	0	fresh = !it->second.IsDirty();
98	0	}
99	0	it->second.coin = std::move(coin);
100	0	it->second.AddFlags(CCoinsCacheEntry::DIRTY \| (fresh ? CCoinsCacheEntry::FRESH : 0), *it, m_sentinel); Branch (100:52): [True: 0, False: 0]
101	0	cachedCoinsUsage += it->second.coin.DynamicMemoryUsage();
102	0	TRACE5(utxocache, add,
103	0	outpoint.hash.data(),
104	0	(uint32_t)outpoint.n,
105	0	(uint32_t)it->second.coin.nHeight,
106	0	(int64_t)it->second.coin.out.nValue,
107	0	(bool)it->second.coin.IsCoinBase());
108	0	}
109
110	0	void CCoinsViewCache::EmplaceCoinInternalDANGER(COutPoint&& outpoint, Coin&& coin) {
111	0	cachedCoinsUsage += coin.DynamicMemoryUsage();
112	0	auto [it, inserted] = cacheCoins.emplace(
113	0	std::piecewise_construct,
114	0	std::forward_as_tuple(std::move(outpoint)),
115	0	std::forward_as_tuple(std::move(coin)));
116	0	if (inserted) { Branch (116:9): [True: 0, False: 0]
117	0	it->second.AddFlags(CCoinsCacheEntry::DIRTY, *it, m_sentinel);
118	0	}
119	0	}
120
121	0	void AddCoins(CCoinsViewCache& cache, const CTransaction &tx, int nHeight, bool check_for_overwrite) {
122	0	bool fCoinbase = tx.IsCoinBase();
123	0	const Txid& txid = tx.GetHash();
124	0	for (size_t i = 0; i < tx.vout.size(); ++i) { Branch (124:24): [True: 0, False: 0]
125	0	bool overwrite = check_for_overwrite ? cache.HaveCoin(COutPoint(txid, i)) : fCoinbase; Branch (125:26): [True: 0, False: 0]
126		// Coinbase transactions can always be overwritten, in order to correctly
127		// deal with the pre-BIP30 occurrences of duplicate coinbase transactions.
128	0	cache.AddCoin(COutPoint(txid, i), Coin(tx.vout[i], nHeight, fCoinbase), overwrite);
129	0	}
130	0	}
131
132	0	bool CCoinsViewCache::SpendCoin(const COutPoint &outpoint, Coin* moveout) {
133	0	CCoinsMap::iterator it = FetchCoin(outpoint);
134	0	if (it == cacheCoins.end()) return false; Branch (134:9): [True: 0, False: 0]
135	0	cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
136	0	TRACE5(utxocache, spent,
137	0	outpoint.hash.data(),
138	0	(uint32_t)outpoint.n,
139	0	(uint32_t)it->second.coin.nHeight,
140	0	(int64_t)it->second.coin.out.nValue,
141	0	(bool)it->second.coin.IsCoinBase());
142	0	if (moveout) { Branch (142:9): [True: 0, False: 0]
143	0	*moveout = std::move(it->second.coin);
144	0	}
145	0	if (it->second.IsFresh()) { Branch (145:9): [True: 0, False: 0]
146	0	cacheCoins.erase(it);
147	0	} else {
148	0	it->second.AddFlags(CCoinsCacheEntry::DIRTY, *it, m_sentinel);
149	0	it->second.coin.Clear();
150	0	}
151	0	return true;
152	0	}
153
154		static const Coin coinEmpty;
155
156	0	const Coin& CCoinsViewCache::AccessCoin(const COutPoint &outpoint) const {
157	0	CCoinsMap::const_iterator it = FetchCoin(outpoint);
158	0	if (it == cacheCoins.end()) { Branch (158:9): [True: 0, False: 0]
159	0	return coinEmpty;
160	0	} else {
161	0	return it->second.coin;
162	0	}
163	0	}
164
165	0	bool CCoinsViewCache::HaveCoin(const COutPoint &outpoint) const {
166	0	CCoinsMap::const_iterator it = FetchCoin(outpoint);
167	0	return (it != cacheCoins.end() && !it->second.coin.IsSpent()); Branch (167:13): [True: 0, False: 0] Branch (167:39): [True: 0, False: 0]
168	0	}
169
170	0	bool CCoinsViewCache::HaveCoinInCache(const COutPoint &outpoint) const {
171	0	CCoinsMap::const_iterator it = cacheCoins.find(outpoint);
172	0	return (it != cacheCoins.end() && !it->second.coin.IsSpent()); Branch (172:13): [True: 0, False: 0] Branch (172:39): [True: 0, False: 0]
173	0	}
174
175	0	uint256 CCoinsViewCache::GetBestBlock() const {
176	0	if (hashBlock.IsNull()) Branch (176:9): [True: 0, False: 0]
177	0	hashBlock = base->GetBestBlock();
178	0	return hashBlock;
179	0	}
180
181	0	void CCoinsViewCache::SetBestBlock(const uint256 &hashBlockIn) {
182	0	hashBlock = hashBlockIn;
183	0	}
184
185	0	bool CCoinsViewCache::BatchWrite(CoinsViewCacheCursor& cursor, const uint256 &hashBlockIn) {
186	0	for (auto it{cursor.Begin()}; it != cursor.End(); it = cursor.NextAndMaybeErase(*it)) { Branch (186:35): [True: 0, False: 0]
187		// Ignore non-dirty entries (optimization).
188	0	if (!it->second.IsDirty()) { Branch (188:13): [True: 0, False: 0]
189	0	continue;
190	0	}
191	0	CCoinsMap::iterator itUs = cacheCoins.find(it->first);
192	0	if (itUs == cacheCoins.end()) { Branch (192:13): [True: 0, False: 0]
193		// The parent cache does not have an entry, while the child cache does.
194		// We can ignore it if it's both spent and FRESH in the child
195	0	if (!(it->second.IsFresh() && it->second.coin.IsSpent())) { Branch (195:19): [True: 0, False: 0] Branch (195:43): [True: 0, False: 0]
196		// Create the coin in the parent cache, move the data up
197		// and mark it as dirty.
198	0	itUs = cacheCoins.try_emplace(it->first).first;
199	0	CCoinsCacheEntry& entry{itUs->second};
200	0	if (cursor.WillErase(*it)) { Branch (200:21): [True: 0, False: 0]
201		// Since this entry will be erased,
202		// we can move the coin into us instead of copying it
203	0	entry.coin = std::move(it->second.coin);
204	0	} else {
205	0	entry.coin = it->second.coin;
206	0	}
207	0	cachedCoinsUsage += entry.coin.DynamicMemoryUsage();
208	0	entry.AddFlags(CCoinsCacheEntry::DIRTY, *itUs, m_sentinel);
209		// We can mark it FRESH in the parent if it was FRESH in the child
210		// Otherwise it might have just been flushed from the parent's cache
211		// and already exist in the grandparent
212	0	if (it->second.IsFresh()) { Branch (212:21): [True: 0, False: 0]
213	0	entry.AddFlags(CCoinsCacheEntry::FRESH, *itUs, m_sentinel);
214	0	}
215	0	}
216	0	} else {
217		// Found the entry in the parent cache
218	0	if (it->second.IsFresh() && !itUs->second.coin.IsSpent()) { Branch (218:17): [True: 0, False: 0] Branch (218:41): [True: 0, False: 0]
219		// The coin was marked FRESH in the child cache, but the coin
220		// exists in the parent cache. If this ever happens, it means
221		// the FRESH flag was misapplied and there is a logic error in
222		// the calling code.
223	0	throw std::logic_error("FRESH flag misapplied to coin that exists in parent cache");
224	0	}
225
226	0	if (itUs->second.IsFresh() && it->second.coin.IsSpent()) { Branch (226:17): [True: 0, False: 0] Branch (226:43): [True: 0, False: 0]
227		// The grandparent cache does not have an entry, and the coin
228		// has been spent. We can just delete it from the parent cache.
229	0	cachedCoinsUsage -= itUs->second.coin.DynamicMemoryUsage();
230	0	cacheCoins.erase(itUs);
231	0	} else {
232		// A normal modification.
233	0	cachedCoinsUsage -= itUs->second.coin.DynamicMemoryUsage();
234	0	if (cursor.WillErase(*it)) { Branch (234:21): [True: 0, False: 0]
235		// Since this entry will be erased,
236		// we can move the coin into us instead of copying it
237	0	itUs->second.coin = std::move(it->second.coin);
238	0	} else {
239	0	itUs->second.coin = it->second.coin;
240	0	}
241	0	cachedCoinsUsage += itUs->second.coin.DynamicMemoryUsage();
242	0	itUs->second.AddFlags(CCoinsCacheEntry::DIRTY, *itUs, m_sentinel);
243		// NOTE: It isn't safe to mark the coin as FRESH in the parent
244		// cache. If it already existed and was spent in the parent
245		// cache then marking it FRESH would prevent that spentness
246		// from being flushed to the grandparent.
247	0	}
248	0	}
249	0	}
250	0	hashBlock = hashBlockIn;
251	0	return true;
252	0	}
253
254	0	bool CCoinsViewCache::Flush() {
255	0	auto cursor{CoinsViewCacheCursor(cachedCoinsUsage, m_sentinel, cacheCoins, /will_erase=/true)};
256	0	bool fOk = base->BatchWrite(cursor, hashBlock);
257	0	if (fOk) { Branch (257:9): [True: 0, False: 0]
258	0	cacheCoins.clear();
259	0	ReallocateCache();
260	0	}
261	0	cachedCoinsUsage = 0;
262	0	return fOk;
263	0	}
264
265		bool CCoinsViewCache::Sync()
266	0	{
267	0	auto cursor{CoinsViewCacheCursor(cachedCoinsUsage, m_sentinel, cacheCoins, /will_erase=/false)};
268	0	bool fOk = base->BatchWrite(cursor, hashBlock);
269	0	if (fOk) { Branch (269:9): [True: 0, False: 0]
270	0	if (m_sentinel.second.Next() != &m_sentinel) { Branch (270:13): [True: 0, False: 0]
271		/* BatchWrite must clear flags of all entries */
272	0	throw std::logic_error("Not all unspent flagged entries were cleared");
273	0	}
274	0	}
275	0	return fOk;
276	0	}
277
278		void CCoinsViewCache::Uncache(const COutPoint& hash)
279	0	{
280	0	CCoinsMap::iterator it = cacheCoins.find(hash);
281	0	if (it != cacheCoins.end() && !it->second.IsDirty() && !it->second.IsFresh()) { Branch (281:9): [True: 0, False: 0] Branch (281:9): [True: 0, False: 0] Branch (281:35): [True: 0, False: 0] Branch (281:60): [True: 0, False: 0]
282	0	cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
283	0	TRACE5(utxocache, uncache,
284	0	hash.hash.data(),
285	0	(uint32_t)hash.n,
286	0	(uint32_t)it->second.coin.nHeight,
287	0	(int64_t)it->second.coin.out.nValue,
288	0	(bool)it->second.coin.IsCoinBase());
289	0	cacheCoins.erase(it);
290	0	}
291	0	}
292
293	0	unsigned int CCoinsViewCache::GetCacheSize() const {
294	0	return cacheCoins.size();
295	0	}
296
297		bool CCoinsViewCache::HaveInputs(const CTransaction& tx) const
298	0	{
299	0	if (!tx.IsCoinBase()) { Branch (299:9): [True: 0, False: 0]
300	0	for (unsigned int i = 0; i < tx.vin.size(); i++) { Branch (300:34): [True: 0, False: 0]
301	0	if (!HaveCoin(tx.vin[i].prevout)) { Branch (301:17): [True: 0, False: 0]
302	0	return false;
303	0	}
304	0	}
305	0	}
306	0	return true;
307	0	}
308
309		void CCoinsViewCache::ReallocateCache()
310	0	{
311		// Cache should be empty when we're calling this.
312	0	assert(cacheCoins.size() == 0);
313	0	cacheCoins.~CCoinsMap();
314	0	m_cache_coins_memory_resource.~CCoinsMapMemoryResource();
315	0	::new (&m_cache_coins_memory_resource) CCoinsMapMemoryResource{};
316	0	::new (&cacheCoins) CCoinsMap{0, SaltedOutpointHasher{/deterministic=/m_deterministic}, CCoinsMap::key_equal{}, &m_cache_coins_memory_resource};
317	0	}
318
319		void CCoinsViewCache::SanityCheck() const
320	0	{
321	0	size_t recomputed_usage = 0;
322	0	size_t count_flagged = 0;
323	0	for (const auto& [_, entry] : cacheCoins) { Branch (323:33): [True: 0, False: 0]
324	0	unsigned attr = 0;
325	0	if (entry.IsDirty()) attr \|= 1; Branch (325:13): [True: 0, False: 0]
326	0	if (entry.IsFresh()) attr \|= 2; Branch (326:13): [True: 0, False: 0]
327	0	if (entry.coin.IsSpent()) attr \|= 4; Branch (327:13): [True: 0, False: 0]
328		// Only 5 combinations are possible.
329	0	assert(attr != 2 && attr != 4 && attr != 7);
330
331		// Recompute cachedCoinsUsage.
332	0	recomputed_usage += entry.coin.DynamicMemoryUsage();
333
334		// Count the number of entries we expect in the linked list.
335	0	if (entry.IsDirty() \|\| entry.IsFresh()) ++count_flagged; Branch (335:13): [True: 0, False: 0] Branch (335:32): [True: 0, False: 0]
336	0	}
337		// Iterate over the linked list of flagged entries.
338	0	size_t count_linked = 0;
339	0	for (auto it = m_sentinel.second.Next(); it != &m_sentinel; it = it->second.Next()) { Branch (339:46): [True: 0, False: 0]
340		// Verify linked list integrity.
341	0	assert(it->second.Next()->second.Prev() == it);
342	0	assert(it->second.Prev()->second.Next() == it);
343		// Verify they are actually flagged.
344	0	assert(it->second.IsDirty() \|\| it->second.IsFresh());
345		// Count the number of entries actually in the list.
346	0	++count_linked;
347	0	}
348	0	assert(count_linked == count_flagged);
349	0	assert(recomputed_usage == cachedCoinsUsage);
350	0	}
351
352		static const size_t MIN_TRANSACTION_OUTPUT_WEIGHT = WITNESS_SCALE_FACTOR * ::GetSerializeSize(CTxOut());
353		static const size_t MAX_OUTPUTS_PER_BLOCK = MAX_BLOCK_WEIGHT / MIN_TRANSACTION_OUTPUT_WEIGHT;
354
355		const Coin& AccessByTxid(const CCoinsViewCache& view, const Txid& txid)
356	0	{
357	0	COutPoint iter(txid, 0);
358	0	while (iter.n < MAX_OUTPUTS_PER_BLOCK) { Branch (358:12): [True: 0, False: 0]
359	0	const Coin& alternate = view.AccessCoin(iter);
360	0	if (!alternate.IsSpent()) return alternate; Branch (360:13): [True: 0, False: 0]
361	0	++iter.n;
362	0	}
363	0	return coinEmpty;
364	0	}
365
366		template <typename Func>
367		static bool ExecuteBackedWrapper(Func func, const std::vector<std::function<void()>>& err_callbacks)
368	0	{
369	0	try {
370	0	return func();
371	0	} catch(const std::runtime_error& e) {
372	0	for (const auto& f : err_callbacks) { Branch (372:28): [True: 0, False: 0] Branch (372:28): [True: 0, False: 0]
373	0	f();
374	0	}
375	0	LogError("Error reading from database: %s\n", e.what());
376		// Starting the shutdown sequence and returning false to the caller would be
377		// interpreted as 'entry not found' (as opposed to unable to read data), and
378		// could lead to invalid interpretation. Just exit immediately, as we can't
379		// continue anyway, and all writes should be atomic.
380	0	std::abort();
381	0	}
382	0	} Unexecuted instantiation: coins.cpp:bool ExecuteBackedWrapper<CCoinsViewErrorCatcher::GetCoin(COutPoint const&, Coin&) const::$_0>(CCoinsViewErrorCatcher::GetCoin(COutPoint const&, Coin&) const::$_0, std::vector<std::function<void ()>, std::allocator<std::function<void ()> > > const&) Unexecuted instantiation: coins.cpp:bool ExecuteBackedWrapper<CCoinsViewErrorCatcher::HaveCoin(COutPoint const&) const::$_0>(CCoinsViewErrorCatcher::HaveCoin(COutPoint const&) const::$_0, std::vector<std::function<void ()>, std::allocator<std::function<void ()> > > const&)
383
384	0	bool CCoinsViewErrorCatcher::GetCoin(const COutPoint &outpoint, Coin &coin) const {
385	0	return ExecuteBackedWrapper([&]() { return CCoinsViewBacked::GetCoin(outpoint, coin); }, m_err_callbacks);
386	0	}
387
388	0	bool CCoinsViewErrorCatcher::HaveCoin(const COutPoint &outpoint) const {
389	0	return ExecuteBackedWrapper([&]() { return CCoinsViewBacked::HaveCoin(outpoint); }, m_err_callbacks);
390	0	}