LCOV - code coverage report
Current view: top level - src - coins.cpp (source / functions) Coverage Total Hit
Test: fuzz_coverage.info Lines: 92.0 % 199 183
Test Date: 2025-10-19 04:10:16 Functions: 87.8 % 41 36
Branches: 80.4 % 194 156

             Branch data     Line data    Source code
       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                 :             : TRACEPOINT_SEMAPHORE(utxocache, add);
      13                 :             : TRACEPOINT_SEMAPHORE(utxocache, spent);
      14                 :             : TRACEPOINT_SEMAPHORE(utxocache, uncache);
      15                 :             : 
      16                 :      344278 : std::optional<Coin> CCoinsView::GetCoin(const COutPoint& outpoint) const { return std::nullopt; }
      17                 :       10777 : uint256 CCoinsView::GetBestBlock() const { return uint256(); }
      18                 :        5708 : std::vector<uint256> CCoinsView::GetHeadBlocks() const { return std::vector<uint256>(); }
      19                 :       22862 : bool CCoinsView::BatchWrite(CoinsViewCacheCursor& cursor, const uint256 &hashBlock) { return false; }
      20                 :        2854 : std::unique_ptr<CCoinsViewCursor> CCoinsView::Cursor() const { return nullptr; }
      21                 :             : 
      22                 :        2854 : bool CCoinsView::HaveCoin(const COutPoint &outpoint) const
      23                 :             : {
      24                 :        2854 :     return GetCoin(outpoint).has_value();
      25                 :             : }
      26                 :             : 
      27                 :     3274461 : CCoinsViewBacked::CCoinsViewBacked(CCoinsView *viewIn) : base(viewIn) { }
      28                 :     1437183 : std::optional<Coin> CCoinsViewBacked::GetCoin(const COutPoint& outpoint) const { return base->GetCoin(outpoint); }
      29                 :           0 : bool CCoinsViewBacked::HaveCoin(const COutPoint &outpoint) const { return base->HaveCoin(outpoint); }
      30                 :      506768 : uint256 CCoinsViewBacked::GetBestBlock() const { return base->GetBestBlock(); }
      31                 :        5764 : std::vector<uint256> CCoinsViewBacked::GetHeadBlocks() const { return base->GetHeadBlocks(); }
      32                 :     1621106 : void CCoinsViewBacked::SetBackend(CCoinsView &viewIn) { base = &viewIn; }
      33                 :       96885 : bool CCoinsViewBacked::BatchWrite(CoinsViewCacheCursor& cursor, const uint256 &hashBlock) { return base->BatchWrite(cursor, hashBlock); }
      34                 :           0 : std::unique_ptr<CCoinsViewCursor> CCoinsViewBacked::Cursor() const { return base->Cursor(); }
      35                 :        5764 : size_t CCoinsViewBacked::EstimateSize() const { return base->EstimateSize(); }
      36                 :             : 
      37                 :     1839850 : CCoinsViewCache::CCoinsViewCache(CCoinsView* baseIn, bool deterministic) :
      38                 :     1839850 :     CCoinsViewBacked(baseIn), m_deterministic(deterministic),
      39   [ +  -  +  - ]:     1839850 :     cacheCoins(0, SaltedOutpointHasher(/*deterministic=*/deterministic), CCoinsMap::key_equal{}, &m_cache_coins_memory_resource)
      40                 :             : {
      41                 :     1839850 :     m_sentinel.second.SelfRef(m_sentinel);
      42                 :     1839850 : }
      43                 :             : 
      44                 :     3809557 : size_t CCoinsViewCache::DynamicMemoryUsage() const {
      45                 :     3809557 :     return memusage::DynamicUsage(cacheCoins) + cachedCoinsUsage;
      46                 :             : }
      47                 :             : 
      48                 :    26485650 : CCoinsMap::iterator CCoinsViewCache::FetchCoin(const COutPoint &outpoint) const {
      49         [ +  + ]:    26485650 :     const auto [ret, inserted] = cacheCoins.try_emplace(outpoint);
      50         [ +  + ]:    26485650 :     if (inserted) {
      51         [ +  + ]:     5561146 :         if (auto coin{base->GetCoin(outpoint)}) {
      52                 :     2694139 :             ret->second.coin = std::move(*coin);
      53         [ +  + ]:     2694139 :             cachedCoinsUsage += ret->second.coin.DynamicMemoryUsage();
      54         [ +  + ]:     2694139 :             if (ret->second.coin.IsSpent()) { // TODO GetCoin cannot return spent coins
      55                 :             :                 // The parent only has an empty entry for this outpoint; we can consider our version as fresh.
      56                 :        2857 :                 CCoinsCacheEntry::SetFresh(*ret, m_sentinel);
      57                 :             :             }
      58                 :             :         } else {
      59                 :     2867007 :             cacheCoins.erase(ret);
      60                 :     2867007 :             return cacheCoins.end();
      61                 :     5561146 :         }
      62                 :             :     }
      63                 :    23618643 :     return ret;
      64                 :             : }
      65                 :             : 
      66                 :     8625932 : std::optional<Coin> CCoinsViewCache::GetCoin(const COutPoint& outpoint) const
      67                 :             : {
      68   [ +  +  +  + ]:     8625932 :     if (auto it{FetchCoin(outpoint)}; it != cacheCoins.end() && !it->second.coin.IsSpent()) return it->second.coin;
      69                 :     1065900 :     return std::nullopt;
      70                 :             : }
      71                 :             : 
      72                 :     1739212 : void CCoinsViewCache::AddCoin(const COutPoint &outpoint, Coin&& coin, bool possible_overwrite) {
      73         [ -  + ]:     1739212 :     assert(!coin.IsSpent());
      74         [ +  + ]:     1739212 :     if (coin.out.scriptPubKey.IsUnspendable()) return;
      75                 :     1492872 :     CCoinsMap::iterator it;
      76                 :     1492872 :     bool inserted;
      77         [ +  + ]:     1492872 :     std::tie(it, inserted) = cacheCoins.emplace(std::piecewise_construct, std::forward_as_tuple(outpoint), std::tuple<>());
      78                 :     1492872 :     bool fresh = false;
      79         [ +  + ]:     1492872 :     if (!possible_overwrite) {
      80         [ +  + ]:     1038067 :         if (!it->second.coin.IsSpent()) {
      81         [ +  - ]:         125 :             throw std::logic_error("Attempted to overwrite an unspent coin (when possible_overwrite is false)");
      82                 :             :         }
      83                 :             :         // If the coin exists in this cache as a spent coin and is DIRTY, then
      84                 :             :         // its spentness hasn't been flushed to the parent cache. We're
      85                 :             :         // re-adding the coin to this cache now but we can't mark it as FRESH.
      86                 :             :         // If we mark it FRESH and then spend it before the cache is flushed
      87                 :             :         // we would remove it from this cache and would never flush spentness
      88                 :             :         // to the parent cache.
      89                 :             :         //
      90                 :             :         // Re-adding a spent coin can happen in the case of a re-org (the coin
      91                 :             :         // is 'spent' when the block adding it is disconnected and then
      92                 :             :         // re-added when it is also added in a newly connected block).
      93                 :             :         //
      94                 :             :         // If the coin doesn't exist in the current cache, or is spent but not
      95                 :             :         // DIRTY, then it can be marked FRESH.
      96                 :     1037942 :         fresh = !it->second.IsDirty();
      97                 :             :     }
      98         [ +  + ]:     1492747 :     if (!inserted) {
      99         [ +  + ]:       22854 :         cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
     100                 :             :     }
     101                 :     1492747 :     it->second.coin = std::move(coin);
     102                 :     1492747 :     CCoinsCacheEntry::SetDirty(*it, m_sentinel);
     103         [ +  + ]:     1492747 :     if (fresh) CCoinsCacheEntry::SetFresh(*it, m_sentinel);
     104         [ +  + ]:     1501086 :     cachedCoinsUsage += it->second.coin.DynamicMemoryUsage();
     105                 :             :     TRACEPOINT(utxocache, add,
     106                 :             :            outpoint.hash.data(),
     107                 :             :            (uint32_t)outpoint.n,
     108                 :             :            (uint32_t)it->second.coin.nHeight,
     109                 :             :            (int64_t)it->second.coin.out.nValue,
     110                 :     1739087 :            (bool)it->second.coin.IsCoinBase());
     111                 :             : }
     112                 :             : 
     113                 :      398492 : void CCoinsViewCache::EmplaceCoinInternalDANGER(COutPoint&& outpoint, Coin&& coin) {
     114         [ +  + ]:      398492 :     const auto mem_usage{coin.DynamicMemoryUsage()};
     115         [ +  + ]:      398492 :     auto [it, inserted] = cacheCoins.try_emplace(std::move(outpoint), std::move(coin));
     116         [ +  + ]:      398492 :     if (inserted) {
     117                 :      105239 :         CCoinsCacheEntry::SetDirty(*it, m_sentinel);
     118                 :      105239 :         cachedCoinsUsage += mem_usage;
     119                 :             :     }
     120                 :      398492 : }
     121                 :             : 
     122                 :      357315 : void AddCoins(CCoinsViewCache& cache, const CTransaction &tx, int nHeight, bool check_for_overwrite) {
     123                 :      357315 :     bool fCoinbase = tx.IsCoinBase();
     124                 :      357315 :     const Txid& txid = tx.GetHash();
     125   [ -  +  +  + ]:     1989279 :     for (size_t i = 0; i < tx.vout.size(); ++i) {
     126         [ +  + ]:     1631967 :         bool overwrite = check_for_overwrite ? cache.HaveCoin(COutPoint(txid, i)) : fCoinbase;
     127                 :             :         // Coinbase transactions can always be overwritten, in order to correctly
     128                 :             :         // deal with the pre-BIP30 occurrences of duplicate coinbase transactions.
     129         [ +  + ]:     3263931 :         cache.AddCoin(COutPoint(txid, i), Coin(tx.vout[i], nHeight, fCoinbase), overwrite);
     130                 :             :     }
     131                 :      357312 : }
     132                 :             : 
     133                 :      266521 : bool CCoinsViewCache::SpendCoin(const COutPoint &outpoint, Coin* moveout) {
     134                 :      266521 :     CCoinsMap::iterator it = FetchCoin(outpoint);
     135         [ +  + ]:      266521 :     if (it == cacheCoins.end()) return false;
     136         [ +  + ]:      211146 :     cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
     137                 :             :     TRACEPOINT(utxocache, spent,
     138                 :             :            outpoint.hash.data(),
     139                 :             :            (uint32_t)outpoint.n,
     140                 :             :            (uint32_t)it->second.coin.nHeight,
     141                 :             :            (int64_t)it->second.coin.out.nValue,
     142                 :      211146 :            (bool)it->second.coin.IsCoinBase());
     143         [ +  + ]:      211146 :     if (moveout) {
     144                 :       46911 :         *moveout = std::move(it->second.coin);
     145                 :             :     }
     146         [ +  + ]:      211146 :     if (it->second.IsFresh()) {
     147                 :       50216 :         cacheCoins.erase(it);
     148                 :             :     } else {
     149                 :      160930 :         CCoinsCacheEntry::SetDirty(*it, m_sentinel);
     150                 :      160930 :         it->second.coin.Clear();
     151                 :             :     }
     152                 :             :     return true;
     153                 :             : }
     154                 :             : 
     155                 :             : static const Coin coinEmpty;
     156                 :             : 
     157                 :    11903239 : const Coin& CCoinsViewCache::AccessCoin(const COutPoint &outpoint) const {
     158         [ +  + ]:    11903239 :     CCoinsMap::const_iterator it = FetchCoin(outpoint);
     159         [ +  + ]:    11903239 :     if (it == cacheCoins.end()) {
     160                 :             :         return coinEmpty;
     161                 :             :     } else {
     162                 :    11231907 :         return it->second.coin;
     163                 :             :     }
     164                 :             : }
     165                 :             : 
     166                 :     5689958 : bool CCoinsViewCache::HaveCoin(const COutPoint &outpoint) const {
     167         [ +  + ]:     5689958 :     CCoinsMap::const_iterator it = FetchCoin(outpoint);
     168   [ +  +  +  + ]:     5689958 :     return (it != cacheCoins.end() && !it->second.coin.IsSpent());
     169                 :             : }
     170                 :             : 
     171                 :     5006803 : bool CCoinsViewCache::HaveCoinInCache(const COutPoint &outpoint) const {
     172         [ +  + ]:     5006803 :     CCoinsMap::const_iterator it = cacheCoins.find(outpoint);
     173   [ +  +  +  + ]:     5006803 :     return (it != cacheCoins.end() && !it->second.coin.IsSpent());
     174                 :             : }
     175                 :             : 
     176                 :     2461599 : uint256 CCoinsViewCache::GetBestBlock() const {
     177         [ +  + ]:     4923198 :     if (hashBlock.IsNull())
     178                 :      759150 :         hashBlock = base->GetBestBlock();
     179                 :     2461599 :     return hashBlock;
     180                 :             : }
     181                 :             : 
     182                 :      116014 : void CCoinsViewCache::SetBestBlock(const uint256 &hashBlockIn) {
     183                 :      116014 :     hashBlock = hashBlockIn;
     184                 :      116014 : }
     185                 :             : 
     186                 :      186850 : bool CCoinsViewCache::BatchWrite(CoinsViewCacheCursor& cursor, const uint256 &hashBlockIn) {
     187         [ +  + ]:      445766 :     for (auto it{cursor.Begin()}; it != cursor.End(); it = cursor.NextAndMaybeErase(*it)) {
     188                 :             :         // Ignore non-dirty entries (optimization).
     189         [ +  + ]:      261217 :         if (!it->second.IsDirty()) {
     190                 :        1027 :             continue;
     191                 :             :         }
     192                 :      260190 :         CCoinsMap::iterator itUs = cacheCoins.find(it->first);
     193         [ +  + ]:      260190 :         if (itUs == cacheCoins.end()) {
     194                 :             :             // The parent cache does not have an entry, while the child cache does.
     195                 :             :             // We can ignore it if it's both spent and FRESH in the child
     196   [ +  +  +  + ]:      209727 :             if (!(it->second.IsFresh() && it->second.coin.IsSpent())) {
     197                 :             :                 // Create the coin in the parent cache, move the data up
     198                 :             :                 // and mark it as dirty.
     199                 :      206064 :                 itUs = cacheCoins.try_emplace(it->first).first;
     200         [ -  + ]:      206064 :                 CCoinsCacheEntry& entry{itUs->second};
     201   [ -  +  -  - ]:      206064 :                 assert(entry.coin.DynamicMemoryUsage() == 0);
     202         [ +  + ]:      206064 :                 if (cursor.WillErase(*it)) {
     203                 :             :                     // Since this entry will be erased,
     204                 :             :                     // we can move the coin into us instead of copying it
     205                 :      144849 :                     entry.coin = std::move(it->second.coin);
     206                 :             :                 } else {
     207                 :       61215 :                     entry.coin = it->second.coin;
     208                 :             :                 }
     209         [ +  + ]:      206064 :                 cachedCoinsUsage += entry.coin.DynamicMemoryUsage();
     210                 :      206064 :                 CCoinsCacheEntry::SetDirty(*itUs, m_sentinel);
     211                 :             :                 // We can mark it FRESH in the parent if it was FRESH in the child
     212                 :             :                 // Otherwise it might have just been flushed from the parent's cache
     213                 :             :                 // and already exist in the grandparent
     214         [ +  + ]:      206064 :                 if (it->second.IsFresh()) CCoinsCacheEntry::SetFresh(*itUs, m_sentinel);
     215                 :             :             }
     216                 :             :         } else {
     217                 :             :             // Found the entry in the parent cache
     218   [ +  +  +  + ]:       50463 :             if (it->second.IsFresh() && !itUs->second.coin.IsSpent()) {
     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         [ +  - ]:        2301 :                 throw std::logic_error("FRESH flag misapplied to coin that exists in parent cache");
     224                 :             :             }
     225                 :             : 
     226   [ +  +  +  + ]:       48162 :             if (itUs->second.IsFresh() && it->second.coin.IsSpent()) {
     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         [ +  + ]:        3480 :                 cachedCoinsUsage -= itUs->second.coin.DynamicMemoryUsage();
     230                 :        3480 :                 cacheCoins.erase(itUs);
     231                 :             :             } else {
     232                 :             :                 // A normal modification.
     233         [ +  + ]:       44682 :                 cachedCoinsUsage -= itUs->second.coin.DynamicMemoryUsage();
     234         [ +  + ]:       44682 :                 if (cursor.WillErase(*it)) {
     235                 :             :                     // Since this entry will be erased,
     236                 :             :                     // we can move the coin into us instead of copying it
     237                 :       29885 :                     itUs->second.coin = std::move(it->second.coin);
     238                 :             :                 } else {
     239                 :       14797 :                     itUs->second.coin = it->second.coin;
     240                 :             :                 }
     241         [ +  + ]:       44682 :                 cachedCoinsUsage += itUs->second.coin.DynamicMemoryUsage();
     242                 :       44682 :                 CCoinsCacheEntry::SetDirty(*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                 :             :             }
     248                 :             :         }
     249                 :             :     }
     250                 :      184549 :     hashBlock = hashBlockIn;
     251                 :      184549 :     return true;
     252                 :             : }
     253                 :             : 
     254                 :      394204 : bool CCoinsViewCache::Flush() {
     255                 :      394204 :     auto cursor{CoinsViewCacheCursor(m_sentinel, cacheCoins, /*will_erase=*/true)};
     256                 :      394204 :     bool fOk = base->BatchWrite(cursor, hashBlock);
     257         [ +  + ]:      394204 :     if (fOk) {
     258                 :      389667 :         cacheCoins.clear();
     259                 :      389667 :         ReallocateCache();
     260                 :      389667 :         cachedCoinsUsage = 0;
     261                 :             :     }
     262                 :      394204 :     return fOk;
     263                 :             : }
     264                 :             : 
     265                 :      258298 : bool CCoinsViewCache::Sync()
     266                 :             : {
     267                 :      258298 :     auto cursor{CoinsViewCacheCursor(m_sentinel, cacheCoins, /*will_erase=*/false)};
     268                 :      258298 :     bool fOk = base->BatchWrite(cursor, hashBlock);
     269         [ +  + ]:      258298 :     if (fOk) {
     270         [ -  + ]:      239973 :         if (m_sentinel.second.Next() != &m_sentinel) {
     271                 :             :             /* BatchWrite must clear flags of all entries */
     272         [ #  # ]:           0 :             throw std::logic_error("Not all unspent flagged entries were cleared");
     273                 :             :         }
     274                 :             :     }
     275                 :      258298 :     return fOk;
     276                 :             : }
     277                 :             : 
     278                 :     2195583 : void CCoinsViewCache::Uncache(const COutPoint& hash)
     279                 :             : {
     280                 :     2195583 :     CCoinsMap::iterator it = cacheCoins.find(hash);
     281   [ +  +  +  +  :     2195583 :     if (it != cacheCoins.end() && !it->second.IsDirty() && !it->second.IsFresh()) {
                   +  + ]
     282         [ +  + ]:      534693 :         cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
     283                 :             :         TRACEPOINT(utxocache, uncache,
     284                 :             :                hash.hash.data(),
     285                 :             :                (uint32_t)hash.n,
     286                 :             :                (uint32_t)it->second.coin.nHeight,
     287                 :             :                (int64_t)it->second.coin.out.nValue,
     288                 :      534693 :                (bool)it->second.coin.IsCoinBase());
     289                 :      534693 :         cacheCoins.erase(it);
     290                 :             :     }
     291                 :     2195583 : }
     292                 :             : 
     293                 :     2063321 : unsigned int CCoinsViewCache::GetCacheSize() const {
     294                 :     2063321 :     return cacheCoins.size();
     295                 :             : }
     296                 :             : 
     297                 :      760113 : bool CCoinsViewCache::HaveInputs(const CTransaction& tx) const
     298                 :             : {
     299         [ +  + ]:      760113 :     if (!tx.IsCoinBase()) {
     300   [ -  +  +  + ]:     2781180 :         for (unsigned int i = 0; i < tx.vin.size(); i++) {
     301         [ +  + ]:     2029480 :             if (!HaveCoin(tx.vin[i].prevout)) {
     302                 :             :                 return false;
     303                 :             :             }
     304                 :             :         }
     305                 :             :     }
     306                 :             :     return true;
     307                 :             : }
     308                 :             : 
     309                 :      412159 : void CCoinsViewCache::ReallocateCache()
     310                 :             : {
     311                 :             :     // Cache should be empty when we're calling this.
     312         [ -  + ]:      412159 :     assert(cacheCoins.size() == 0);
     313                 :      412159 :     cacheCoins.~CCoinsMap();
     314                 :      412159 :     m_cache_coins_memory_resource.~CCoinsMapMemoryResource();
     315                 :      412159 :     ::new (&m_cache_coins_memory_resource) CCoinsMapMemoryResource{};
     316                 :      412159 :     ::new (&cacheCoins) CCoinsMap{0, SaltedOutpointHasher{/*deterministic=*/m_deterministic}, CCoinsMap::key_equal{}, &m_cache_coins_memory_resource};
     317                 :      412159 : }
     318                 :             : 
     319                 :       23377 : void CCoinsViewCache::SanityCheck() const
     320                 :             : {
     321                 :       23377 :     size_t recomputed_usage = 0;
     322                 :       23377 :     size_t count_flagged = 0;
     323   [ +  +  +  + ]:       90057 :     for (const auto& [_, entry] : cacheCoins) {
     324                 :       66680 :         unsigned attr = 0;
     325         [ +  + ]:       66680 :         if (entry.IsDirty()) attr |= 1;
     326         [ +  + ]:       66680 :         if (entry.IsFresh()) attr |= 2;
     327         [ +  + ]:       66680 :         if (entry.coin.IsSpent()) attr |= 4;
     328                 :             :         // Only 5 combinations are possible.
     329   [ +  -  -  + ]:       66680 :         assert(attr != 2 && attr != 4 && attr != 7);
     330                 :             : 
     331                 :             :         // Recompute cachedCoinsUsage.
     332         [ -  + ]:       66680 :         recomputed_usage += entry.coin.DynamicMemoryUsage();
     333                 :             : 
     334                 :             :         // Count the number of entries we expect in the linked list.
     335   [ +  +  +  + ]:       66680 :         if (entry.IsDirty() || entry.IsFresh()) ++count_flagged;
     336                 :             :     }
     337                 :             :     // Iterate over the linked list of flagged entries.
     338                 :       23377 :     size_t count_linked = 0;
     339         [ +  + ]:       38079 :     for (auto it = m_sentinel.second.Next(); it != &m_sentinel; it = it->second.Next()) {
     340                 :             :         // Verify linked list integrity.
     341         [ -  + ]:       14702 :         assert(it->second.Next()->second.Prev() == it);
     342         [ -  + ]:       14702 :         assert(it->second.Prev()->second.Next() == it);
     343                 :             :         // Verify they are actually flagged.
     344   [ +  +  -  + ]:       14702 :         assert(it->second.IsDirty() || it->second.IsFresh());
     345                 :             :         // Count the number of entries actually in the list.
     346                 :       14702 :         ++count_linked;
     347                 :             :     }
     348         [ -  + ]:       23377 :     assert(count_linked == count_flagged);
     349         [ -  + ]:       23377 :     assert(recomputed_usage == cachedCoinsUsage);
     350                 :       23377 : }
     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                 :           0 : const Coin& AccessByTxid(const CCoinsViewCache& view, const Txid& txid)
     356                 :             : {
     357                 :           0 :     COutPoint iter(txid, 0);
     358         [ #  # ]:           0 :     while (iter.n < MAX_OUTPUTS_PER_BLOCK) {
     359                 :           0 :         const Coin& alternate = view.AccessCoin(iter);
     360         [ #  # ]:           0 :         if (!alternate.IsSpent()) return alternate;
     361                 :           0 :         ++iter.n;
     362                 :             :     }
     363                 :             :     return coinEmpty;
     364                 :             : }
     365                 :             : 
     366                 :             : template <typename ReturnType, typename Func>
     367                 :     1437183 : static ReturnType ExecuteBackedWrapper(Func func, const std::vector<std::function<void()>>& err_callbacks)
     368                 :             : {
     369                 :             :     try {
     370                 :     1437183 :         return func();
     371         [ -  - ]:           0 :     } catch(const std::runtime_error& e) {
     372         [ -  - ]:           0 :         for (const auto& f : err_callbacks) {
     373         [ -  - ]:           0 :             f();
     374                 :             :         }
     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                 :             :     }
     382                 :             : }
     383                 :             : 
     384                 :     1437183 : std::optional<Coin> CCoinsViewErrorCatcher::GetCoin(const COutPoint& outpoint) const
     385                 :             : {
     386         [ +  - ]:     2874366 :     return ExecuteBackedWrapper<std::optional<Coin>>([&]() { return CCoinsViewBacked::GetCoin(outpoint); }, m_err_callbacks);
     387                 :             : }
     388                 :             : 
     389                 :           0 : bool CCoinsViewErrorCatcher::HaveCoin(const COutPoint& outpoint) const
     390                 :             : {
     391         [ #  # ]:           0 :     return ExecuteBackedWrapper<bool>([&]() { return CCoinsViewBacked::HaveCoin(outpoint); }, m_err_callbacks);
     392                 :             : }
        

Generated by: LCOV version 2.0-1