LCOV - code coverage report
Current view: top level - src - validation.cpp (source / functions) Hit Total Coverage
Test: fuzz_coverage.info Lines: 650 3045 21.3 %
Date: 2023-10-05 12:38:51 Functions: 64 193 33.2 %
Branches: 509 6008 8.5 %

           Branch data     Line data    Source code
       1                 :            : // Copyright (c) 2009-2010 Satoshi Nakamoto
       2                 :            : // Copyright (c) 2009-2022 The Bitcoin Core developers
       3                 :            : // Distributed under the MIT software license, see the accompanying
       4                 :            : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       5                 :            : 
       6                 :            : #include <validation.h>
       7                 :            : 
       8                 :            : #include <kernel/chain.h>
       9                 :            : #include <kernel/coinstats.h>
      10                 :            : #include <kernel/mempool_persist.h>
      11                 :            : 
      12                 :            : #include <arith_uint256.h>
      13                 :            : #include <chain.h>
      14                 :            : #include <checkqueue.h>
      15                 :            : #include <clientversion.h>
      16                 :            : #include <consensus/amount.h>
      17         [ +  - ]:          2 : #include <consensus/consensus.h>
      18         [ +  - ]:          2 : #include <consensus/merkle.h>
      19                 :            : #include <consensus/tx_check.h>
      20                 :            : #include <consensus/tx_verify.h>
      21                 :            : #include <consensus/validation.h>
      22                 :            : #include <cuckoocache.h>
      23                 :            : #include <flatfile.h>
      24                 :            : #include <hash.h>
      25                 :            : #include <kernel/chainparams.h>
      26                 :            : #include <kernel/disconnected_transactions.h>
      27                 :            : #include <kernel/mempool_entry.h>
      28                 :            : #include <kernel/messagestartchars.h>
      29                 :            : #include <kernel/notifications_interface.h>
      30                 :            : #include <logging.h>
      31                 :            : #include <logging/timer.h>
      32                 :            : #include <node/blockstorage.h>
      33                 :            : #include <node/utxo_snapshot.h>
      34                 :            : #include <policy/policy.h>
      35                 :            : #include <policy/rbf.h>
      36                 :            : #include <policy/settings.h>
      37                 :            : #include <pow.h>
      38                 :            : #include <primitives/block.h>
      39                 :            : #include <primitives/transaction.h>
      40                 :            : #include <random.h>
      41                 :            : #include <reverse_iterator.h>
      42                 :            : #include <script/script.h>
      43                 :            : #include <script/sigcache.h>
      44                 :            : #include <signet.h>
      45                 :            : #include <tinyformat.h>
      46                 :            : #include <txdb.h>
      47                 :            : #include <txmempool.h>
      48                 :            : #include <uint256.h>
      49                 :            : #include <undo.h>
      50                 :            : #include <util/check.h> // For NDEBUG compile time check
      51                 :          2 : #include <util/fs.h>
      52                 :            : #include <util/fs_helpers.h>
      53                 :            : #include <util/hasher.h>
      54                 :            : #include <util/moneystr.h>
      55                 :            : #include <util/rbf.h>
      56                 :            : #include <util/signalinterrupt.h>
      57                 :            : #include <util/strencodings.h>
      58                 :            : #include <util/time.h>
      59                 :            : #include <util/trace.h>
      60                 :            : #include <util/translation.h>
      61                 :            : #include <validationinterface.h>
      62                 :            : #include <warnings.h>
      63                 :            : 
      64                 :            : #include <algorithm>
      65                 :            : #include <cassert>
      66                 :            : #include <chrono>
      67                 :            : #include <deque>
      68                 :            : #include <numeric>
      69                 :            : #include <optional>
      70                 :            : #include <string>
      71                 :            : #include <utility>
      72                 :            : #include <tuple>
      73                 :            : 
      74                 :          2 : using kernel::CCoinsStats;
      75                 :            : using kernel::CoinStatsHashType;
      76                 :            : using kernel::ComputeUTXOStats;
      77                 :            : using kernel::Notifications;
      78                 :            : 
      79                 :            : using fsbridge::FopenFn;
      80                 :            : using node::BlockManager;
      81                 :            : using node::BlockMap;
      82                 :            : using node::CBlockIndexHeightOnlyComparator;
      83                 :            : using node::CBlockIndexWorkComparator;
      84                 :            : using node::fReindex;
      85                 :            : using node::SnapshotMetadata;
      86                 :            : 
      87                 :            : /** Time to wait between writing blocks/block index to disk. */
      88                 :            : static constexpr std::chrono::hours DATABASE_WRITE_INTERVAL{1};
      89                 :            : /** Time to wait between flushing chainstate to disk. */
      90                 :            : static constexpr std::chrono::hours DATABASE_FLUSH_INTERVAL{24};
      91                 :            : /** Maximum age of our tip for us to be considered current for fee estimation */
      92                 :            : static constexpr std::chrono::hours MAX_FEE_ESTIMATION_TIP_AGE{3};
      93   [ +  -  #  # ]:          2 : const std::vector<std::string> CHECKLEVEL_DOC {
      94         [ +  - ]:          2 :     "level 0 reads the blocks from disk",
      95         [ +  - ]:          2 :     "level 1 verifies block validity",
      96         [ +  - ]:          2 :     "level 2 verifies undo data",
      97         [ +  - ]:          2 :     "level 3 checks disconnection of tip blocks",
      98         [ +  - ]:          2 :     "level 4 tries to reconnect the blocks",
      99         [ +  - ]:          2 :     "each level includes the checks of the previous levels",
     100                 :            : };
     101                 :            : /** The number of blocks to keep below the deepest prune lock.
     102                 :            :  *  There is nothing special about this number. It is higher than what we
     103                 :            :  *  expect to see in regular mainnet reorgs, but not so high that it would
     104                 :            :  *  noticeably interfere with the pruning mechanism.
     105                 :            :  * */
     106                 :            : static constexpr int PRUNE_LOCK_BUFFER{10};
     107                 :            : 
     108                 :            : GlobalMutex g_best_block_mutex;
     109                 :          2 : std::condition_variable g_best_block_cv;
     110                 :            : uint256 g_best_block;
     111                 :            : 
     112                 :          0 : const CBlockIndex* Chainstate::FindForkInGlobalIndex(const CBlockLocator& locator) const
     113                 :            : {
     114                 :          0 :     AssertLockHeld(cs_main);
     115                 :            : 
     116                 :            :     // Find the latest block common to locator and chain - we expect that
     117                 :            :     // locator.vHave is sorted descending by height.
     118         [ #  # ]:          0 :     for (const uint256& hash : locator.vHave) {
     119                 :          0 :         const CBlockIndex* pindex{m_blockman.LookupBlockIndex(hash)};
     120         [ #  # ]:          0 :         if (pindex) {
     121         [ #  # ]:          0 :             if (m_chain.Contains(pindex)) {
     122                 :          0 :                 return pindex;
     123                 :            :             }
     124         [ #  # ]:          0 :             if (pindex->GetAncestor(m_chain.Height()) == m_chain.Tip()) {
     125                 :          0 :                 return m_chain.Tip();
     126                 :            :             }
     127                 :          0 :         }
     128                 :            :     }
     129                 :          0 :     return m_chain.Genesis();
     130                 :          0 : }
     131                 :            : 
     132                 :            : bool CheckInputScripts(const CTransaction& tx, TxValidationState& state,
     133                 :            :                        const CCoinsViewCache& inputs, unsigned int flags, bool cacheSigStore,
     134                 :            :                        bool cacheFullScriptStore, PrecomputedTransactionData& txdata,
     135                 :            :                        std::vector<CScriptCheck>* pvChecks = nullptr)
     136                 :            :                        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     137                 :            : 
     138                 :          0 : bool CheckFinalTxAtTip(const CBlockIndex& active_chain_tip, const CTransaction& tx)
     139                 :            : {
     140                 :          0 :     AssertLockHeld(cs_main);
     141                 :            : 
     142                 :            :     // CheckFinalTxAtTip() uses active_chain_tip.Height()+1 to evaluate
     143                 :            :     // nLockTime because when IsFinalTx() is called within
     144                 :            :     // AcceptBlock(), the height of the block *being*
     145                 :            :     // evaluated is what is used. Thus if we want to know if a
     146                 :            :     // transaction can be part of the *next* block, we need to call
     147                 :            :     // IsFinalTx() with one more than active_chain_tip.Height().
     148                 :          0 :     const int nBlockHeight = active_chain_tip.nHeight + 1;
     149                 :            : 
     150                 :            :     // BIP113 requires that time-locked transactions have nLockTime set to
     151                 :            :     // less than the median time of the previous block they're contained in.
     152                 :            :     // When the next block is created its previous block will be the current
     153                 :            :     // chain tip, so we use that to calculate the median time passed to
     154                 :            :     // IsFinalTx().
     155                 :          0 :     const int64_t nBlockTime{active_chain_tip.GetMedianTimePast()};
     156                 :            : 
     157                 :          0 :     return IsFinalTx(tx, nBlockHeight, nBlockTime);
     158                 :            : }
     159                 :            : 
     160                 :            : namespace {
     161                 :            : /**
     162                 :            :  * A helper which calculates heights of inputs of a given transaction.
     163                 :            :  *
     164                 :            :  * @param[in] tip    The current chain tip. If an input belongs to a mempool
     165                 :            :  *                   transaction, we assume it will be confirmed in the next block.
     166                 :            :  * @param[in] coins  Any CCoinsView that provides access to the relevant coins.
     167                 :            :  * @param[in] tx     The transaction being evaluated.
     168                 :            :  *
     169                 :            :  * @returns A vector of input heights or nullopt, in case of an error.
     170                 :            :  */
     171                 :          0 : std::optional<std::vector<int>> CalculatePrevHeights(
     172                 :            :     const CBlockIndex& tip,
     173                 :            :     const CCoinsView& coins,
     174                 :            :     const CTransaction& tx)
     175                 :            : {
     176                 :          0 :     std::vector<int> prev_heights;
     177         [ #  # ]:          0 :     prev_heights.resize(tx.vin.size());
     178         [ #  # ]:          0 :     for (size_t i = 0; i < tx.vin.size(); ++i) {
     179                 :          0 :         const CTxIn& txin = tx.vin[i];
     180         [ #  # ]:          0 :         Coin coin;
     181   [ #  #  #  # ]:          0 :         if (!coins.GetCoin(txin.prevout, coin)) {
     182   [ #  #  #  #  :          0 :             LogPrintf("ERROR: %s: Missing input %d in transaction \'%s\'\n", __func__, i, tx.GetHash().GetHex());
          #  #  #  #  #  
                      # ]
     183                 :          0 :             return std::nullopt;
     184                 :            :         }
     185         [ #  # ]:          0 :         if (coin.nHeight == MEMPOOL_HEIGHT) {
     186                 :            :             // Assume all mempool transaction confirm in the next block.
     187                 :          0 :             prev_heights[i] = tip.nHeight + 1;
     188                 :          0 :         } else {
     189                 :          0 :             prev_heights[i] = coin.nHeight;
     190                 :            :         }
     191         [ #  # ]:          0 :     }
     192         [ #  # ]:          0 :     return prev_heights;
     193                 :          0 : }
     194                 :            : } // namespace
     195                 :            : 
     196                 :          0 : std::optional<LockPoints> CalculateLockPointsAtTip(
     197                 :            :     CBlockIndex* tip,
     198                 :            :     const CCoinsView& coins_view,
     199                 :            :     const CTransaction& tx)
     200                 :            : {
     201         [ #  # ]:          0 :     assert(tip);
     202                 :            : 
     203                 :          0 :     auto prev_heights{CalculatePrevHeights(*tip, coins_view, tx)};
     204         [ #  # ]:          0 :     if (!prev_heights.has_value()) return std::nullopt;
     205                 :            : 
     206         [ #  # ]:          0 :     CBlockIndex next_tip;
     207                 :          0 :     next_tip.pprev = tip;
     208                 :            :     // When SequenceLocks() is called within ConnectBlock(), the height
     209                 :            :     // of the block *being* evaluated is what is used.
     210                 :            :     // Thus if we want to know if a transaction can be part of the
     211                 :            :     // *next* block, we need to use one more than active_chainstate.m_chain.Height()
     212                 :          0 :     next_tip.nHeight = tip->nHeight + 1;
     213   [ #  #  #  # ]:          0 :     const auto [min_height, min_time] = CalculateSequenceLocks(tx, STANDARD_LOCKTIME_VERIFY_FLAGS, prev_heights.value(), next_tip);
     214                 :            : 
     215                 :            :     // Also store the hash of the block with the highest height of
     216                 :            :     // all the blocks which have sequence locked prevouts.
     217                 :            :     // This hash needs to still be on the chain
     218                 :            :     // for these LockPoint calculations to be valid
     219                 :            :     // Note: It is impossible to correctly calculate a maxInputBlock
     220                 :            :     // if any of the sequence locked inputs depend on unconfirmed txs,
     221                 :            :     // except in the special case where the relative lock time/height
     222                 :            :     // is 0, which is equivalent to no sequence lock. Since we assume
     223                 :            :     // input height of tip+1 for mempool txs and test the resulting
     224                 :            :     // min_height and min_time from CalculateSequenceLocks against tip+1.
     225                 :          0 :     int max_input_height{0};
     226   [ #  #  #  # ]:          0 :     for (const int height : prev_heights.value()) {
     227                 :            :         // Can ignore mempool inputs since we'll fail if they had non-zero locks
     228         [ #  # ]:          0 :         if (height != next_tip.nHeight) {
     229         [ #  # ]:          0 :             max_input_height = std::max(max_input_height, height);
     230                 :          0 :         }
     231                 :            :     }
     232                 :            : 
     233                 :            :     // tip->GetAncestor(max_input_height) should never return a nullptr
     234                 :            :     // because max_input_height is always less than the tip height.
     235                 :            :     // It would, however, be a bad bug to continue execution, since a
     236                 :            :     // LockPoints object with the maxInputBlock member set to nullptr
     237                 :            :     // signifies no relative lock time.
     238   [ #  #  #  #  :          0 :     return LockPoints{min_height, min_time, Assert(tip->GetAncestor(max_input_height))};
          #  #  #  #  #  
                      # ]
     239                 :          0 : }
     240                 :            : 
     241                 :          0 : bool CheckSequenceLocksAtTip(CBlockIndex* tip,
     242                 :            :                              const LockPoints& lock_points)
     243                 :            : {
     244         [ #  # ]:          0 :     assert(tip != nullptr);
     245                 :            : 
     246                 :          0 :     CBlockIndex index;
     247                 :          0 :     index.pprev = tip;
     248                 :            :     // CheckSequenceLocksAtTip() uses active_chainstate.m_chain.Height()+1 to evaluate
     249                 :            :     // height based locks because when SequenceLocks() is called within
     250                 :            :     // ConnectBlock(), the height of the block *being*
     251                 :            :     // evaluated is what is used.
     252                 :            :     // Thus if we want to know if a transaction can be part of the
     253                 :            :     // *next* block, we need to use one more than active_chainstate.m_chain.Height()
     254                 :          0 :     index.nHeight = tip->nHeight + 1;
     255                 :            : 
     256                 :          0 :     return EvaluateSequenceLocks(index, {lock_points.height, lock_points.time});
     257                 :            : }
     258                 :            : 
     259                 :            : // Returns the script flags which should be checked for a given block
     260                 :            : static unsigned int GetBlockScriptFlags(const CBlockIndex& block_index, const ChainstateManager& chainman);
     261                 :            : 
     262                 :          0 : static void LimitMempoolSize(CTxMemPool& pool, CCoinsViewCache& coins_cache)
     263                 :            :     EXCLUSIVE_LOCKS_REQUIRED(::cs_main, pool.cs)
     264                 :            : {
     265                 :          0 :     AssertLockHeld(::cs_main);
     266                 :          0 :     AssertLockHeld(pool.cs);
     267                 :          0 :     int expired = pool.Expire(GetTime<std::chrono::seconds>() - pool.m_expiry);
     268         [ #  # ]:          0 :     if (expired != 0) {
     269   [ #  #  #  #  :          0 :         LogPrint(BCLog::MEMPOOL, "Expired %i transactions from the memory pool\n", expired);
             #  #  #  # ]
     270                 :          0 :     }
     271                 :            : 
     272                 :          0 :     std::vector<COutPoint> vNoSpendsRemaining;
     273         [ #  # ]:          0 :     pool.TrimToSize(pool.m_max_size_bytes, &vNoSpendsRemaining);
     274         [ #  # ]:          0 :     for (const COutPoint& removed : vNoSpendsRemaining)
     275         [ #  # ]:          0 :         coins_cache.Uncache(removed);
     276                 :          0 : }
     277                 :            : 
     278                 :          0 : static bool IsCurrentForFeeEstimation(Chainstate& active_chainstate) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
     279                 :            : {
     280                 :          0 :     AssertLockHeld(cs_main);
     281         [ #  # ]:          0 :     if (active_chainstate.m_chainman.IsInitialBlockDownload()) {
     282                 :          0 :         return false;
     283                 :            :     }
     284         [ #  # ]:          0 :     if (active_chainstate.m_chain.Tip()->GetBlockTime() < count_seconds(GetTime<std::chrono::seconds>() - MAX_FEE_ESTIMATION_TIP_AGE))
     285                 :          0 :         return false;
     286         [ #  # ]:          0 :     if (active_chainstate.m_chain.Height() < active_chainstate.m_chainman.m_best_header->nHeight - 1) {
     287                 :          0 :         return false;
     288                 :            :     }
     289                 :          0 :     return true;
     290                 :          0 : }
     291                 :            : 
     292                 :          0 : void Chainstate::MaybeUpdateMempoolForReorg(
     293                 :            :     DisconnectedBlockTransactions& disconnectpool,
     294                 :            :     bool fAddToMempool)
     295                 :            : {
     296         [ #  # ]:          0 :     if (!m_mempool) return;
     297                 :            : 
     298                 :          0 :     AssertLockHeld(cs_main);
     299                 :          0 :     AssertLockHeld(m_mempool->cs);
     300                 :          0 :     std::vector<uint256> vHashUpdate;
     301                 :            :     {
     302                 :            :         // disconnectpool is ordered so that the front is the most recently-confirmed
     303                 :            :         // transaction (the last tx of the block at the tip) in the disconnected chain.
     304                 :            :         // Iterate disconnectpool in reverse, so that we add transactions
     305                 :            :         // back to the mempool starting with the earliest transaction that had
     306                 :            :         // been previously seen in a block.
     307         [ #  # ]:          0 :         const auto queuedTx = disconnectpool.take();
     308                 :          0 :         auto it = queuedTx.rbegin();
     309   [ #  #  #  # ]:          0 :         while (it != queuedTx.rend()) {
     310                 :            :             // ignore validation errors in resurrected transactions
     311   [ #  #  #  #  :          0 :             if (!fAddToMempool || (*it)->IsCoinBase() ||
          #  #  #  #  #  
                #  #  # ]
     312   [ #  #  #  #  :          0 :                 AcceptToMemoryPool(*this, *it, GetTime(),
                   #  # ]
     313                 :          0 :                     /*bypass_limits=*/true, /*test_accept=*/false).m_result_type !=
     314                 :            :                         MempoolAcceptResult::ResultType::VALID) {
     315                 :            :                 // If the transaction doesn't make it in to the mempool, remove any
     316                 :            :                 // transactions that depend on it (which would now be orphans).
     317   [ #  #  #  # ]:          0 :                 m_mempool->removeRecursive(**it, MemPoolRemovalReason::REORG);
     318   [ #  #  #  #  :          0 :             } else if (m_mempool->exists(GenTxid::Txid((*it)->GetHash()))) {
          #  #  #  #  #  
                      # ]
     319   [ #  #  #  #  :          0 :                 vHashUpdate.push_back((*it)->GetHash());
                   #  # ]
     320                 :          0 :             }
     321         [ #  # ]:          0 :             ++it;
     322                 :            :         }
     323                 :          0 :     }
     324                 :            : 
     325                 :            :     // AcceptToMemoryPool/addUnchecked all assume that new mempool entries have
     326                 :            :     // no in-mempool children, which is generally not true when adding
     327                 :            :     // previously-confirmed transactions back to the mempool.
     328                 :            :     // UpdateTransactionsFromBlock finds descendants of any transactions in
     329                 :            :     // the disconnectpool that were added back and cleans up the mempool state.
     330         [ #  # ]:          0 :     m_mempool->UpdateTransactionsFromBlock(vHashUpdate);
     331                 :            : 
     332                 :            :     // Predicate to use for filtering transactions in removeForReorg.
     333                 :            :     // Checks whether the transaction is still final and, if it spends a coinbase output, mature.
     334                 :            :     // Also updates valid entries' cached LockPoints if needed.
     335                 :            :     // If false, the tx is still valid and its lockpoints are updated.
     336                 :            :     // If true, the tx would be invalid in the next block; remove this entry and all of its descendants.
     337                 :          0 :     const auto filter_final_and_mature = [this](CTxMemPool::txiter it)
     338                 :            :         EXCLUSIVE_LOCKS_REQUIRED(m_mempool->cs, ::cs_main) {
     339                 :          0 :         AssertLockHeld(m_mempool->cs);
     340                 :          0 :         AssertLockHeld(::cs_main);
     341                 :          0 :         const CTransaction& tx = it->GetTx();
     342                 :            : 
     343                 :            :         // The transaction must be final.
     344         [ #  # ]:          0 :         if (!CheckFinalTxAtTip(*Assert(m_chain.Tip()), tx)) return true;
     345                 :            : 
     346                 :          0 :         const LockPoints& lp = it->GetLockPoints();
     347                 :            :         // CheckSequenceLocksAtTip checks if the transaction will be final in the next block to be
     348                 :            :         // created on top of the new chain.
     349         [ #  # ]:          0 :         if (TestLockPointValidity(m_chain, lp)) {
     350         [ #  # ]:          0 :             if (!CheckSequenceLocksAtTip(m_chain.Tip(), lp)) {
     351                 :          0 :                 return true;
     352                 :            :             }
     353                 :          0 :         } else {
     354                 :          0 :             const CCoinsViewMemPool view_mempool{&CoinsTip(), *m_mempool};
     355         [ #  # ]:          0 :             const std::optional<LockPoints> new_lock_points{CalculateLockPointsAtTip(m_chain.Tip(), view_mempool, tx)};
     356   [ #  #  #  #  :          0 :             if (new_lock_points.has_value() && CheckSequenceLocksAtTip(m_chain.Tip(), *new_lock_points)) {
                   #  # ]
     357                 :            :                 // Now update the mempool entry lockpoints as well.
     358         [ #  # ]:          0 :                 m_mempool->mapTx.modify(it, [&new_lock_points](CTxMemPoolEntry& e) { e.UpdateLockPoints(*new_lock_points); });
     359                 :          0 :             } else {
     360                 :          0 :                 return true;
     361                 :            :             }
     362      [ #  #  # ]:          0 :         }
     363                 :            : 
     364                 :            :         // If the transaction spends any coinbase outputs, it must be mature.
     365         [ #  # ]:          0 :         if (it->GetSpendsCoinbase()) {
     366         [ #  # ]:          0 :             for (const CTxIn& txin : tx.vin) {
     367                 :          0 :                 auto it2 = m_mempool->mapTx.find(txin.prevout.hash);
     368         [ #  # ]:          0 :                 if (it2 != m_mempool->mapTx.end())
     369                 :          0 :                     continue;
     370                 :          0 :                 const Coin& coin{CoinsTip().AccessCoin(txin.prevout)};
     371         [ #  # ]:          0 :                 assert(!coin.IsSpent());
     372                 :          0 :                 const auto mempool_spend_height{m_chain.Tip()->nHeight + 1};
     373   [ #  #  #  # ]:          0 :                 if (coin.IsCoinBase() && mempool_spend_height - coin.nHeight < COINBASE_MATURITY) {
     374                 :          0 :                     return true;
     375                 :            :                 }
     376                 :            :             }
     377                 :          0 :         }
     378                 :            :         // Transaction is still valid and cached LockPoints are updated.
     379                 :          0 :         return false;
     380                 :          0 :     };
     381                 :            : 
     382                 :            :     // We also need to remove any now-immature transactions
     383   [ #  #  #  # ]:          0 :     m_mempool->removeForReorg(m_chain, filter_final_and_mature);
     384                 :            :     // Re-limit mempool size, in case we added any transactions
     385   [ #  #  #  # ]:          0 :     LimitMempoolSize(*m_mempool, this->CoinsTip());
     386                 :          0 : }
     387                 :            : 
     388                 :            : /**
     389                 :            : * Checks to avoid mempool polluting consensus critical paths since cached
     390                 :            : * signature and script validity results will be reused if we validate this
     391                 :            : * transaction again during block validation.
     392                 :            : * */
     393                 :          0 : static bool CheckInputsFromMempoolAndCache(const CTransaction& tx, TxValidationState& state,
     394                 :            :                 const CCoinsViewCache& view, const CTxMemPool& pool,
     395                 :            :                 unsigned int flags, PrecomputedTransactionData& txdata, CCoinsViewCache& coins_tip)
     396                 :            :                 EXCLUSIVE_LOCKS_REQUIRED(cs_main, pool.cs)
     397                 :            : {
     398                 :          0 :     AssertLockHeld(cs_main);
     399                 :          0 :     AssertLockHeld(pool.cs);
     400                 :            : 
     401         [ #  # ]:          0 :     assert(!tx.IsCoinBase());
     402         [ #  # ]:          0 :     for (const CTxIn& txin : tx.vin) {
     403                 :          0 :         const Coin& coin = view.AccessCoin(txin.prevout);
     404                 :            : 
     405                 :            :         // This coin was checked in PreChecks and MemPoolAccept
     406                 :            :         // has been holding cs_main since then.
     407                 :          0 :         Assume(!coin.IsSpent());
     408         [ #  # ]:          0 :         if (coin.IsSpent()) return false;
     409                 :            : 
     410                 :            :         // If the Coin is available, there are 2 possibilities:
     411                 :            :         // it is available in our current ChainstateActive UTXO set,
     412                 :            :         // or it's a UTXO provided by a transaction in our mempool.
     413                 :            :         // Ensure the scriptPubKeys in Coins from CoinsView are correct.
     414                 :          0 :         const CTransactionRef& txFrom = pool.get(txin.prevout.hash);
     415         [ #  # ]:          0 :         if (txFrom) {
     416   [ #  #  #  # ]:          0 :             assert(txFrom->GetHash() == txin.prevout.hash);
     417         [ #  # ]:          0 :             assert(txFrom->vout.size() > txin.prevout.n);
     418   [ #  #  #  # ]:          0 :             assert(txFrom->vout[txin.prevout.n] == coin.out);
     419                 :          0 :         } else {
     420         [ #  # ]:          0 :             const Coin& coinFromUTXOSet = coins_tip.AccessCoin(txin.prevout);
     421   [ #  #  #  # ]:          0 :             assert(!coinFromUTXOSet.IsSpent());
     422   [ #  #  #  # ]:          0 :             assert(coinFromUTXOSet.out == coin.out);
     423                 :            :         }
     424                 :          0 :     }
     425                 :            : 
     426                 :            :     // Call CheckInputScripts() to cache signature and script validity against current tip consensus rules.
     427                 :          0 :     return CheckInputScripts(tx, state, view, flags, /* cacheSigStore= */ true, /* cacheFullScriptStore= */ true, txdata);
     428                 :          0 : }
     429                 :            : 
     430                 :            : namespace {
     431                 :            : 
     432                 :            : class MemPoolAccept
     433                 :            : {
     434                 :            : public:
     435                 :          0 :     explicit MemPoolAccept(CTxMemPool& mempool, Chainstate& active_chainstate) :
     436                 :          0 :         m_pool(mempool),
     437                 :          0 :         m_view(&m_dummy),
     438   [ #  #  #  # ]:          0 :         m_viewmempool(&active_chainstate.CoinsTip(), m_pool),
     439                 :          0 :         m_active_chainstate(active_chainstate)
     440                 :            :     {
     441                 :          0 :     }
     442                 :            : 
     443                 :            :     // We put the arguments we're handed into a struct, so we can pass them
     444                 :            :     // around easier.
     445                 :            :     struct ATMPArgs {
     446                 :            :         const CChainParams& m_chainparams;
     447                 :            :         const int64_t m_accept_time;
     448                 :            :         const bool m_bypass_limits;
     449                 :            :         /*
     450                 :            :          * Return any outpoints which were not previously present in the coins
     451                 :            :          * cache, but were added as a result of validating the tx for mempool
     452                 :            :          * acceptance. This allows the caller to optionally remove the cache
     453                 :            :          * additions if the associated transaction ends up being rejected by
     454                 :            :          * the mempool.
     455                 :            :          */
     456                 :            :         std::vector<COutPoint>& m_coins_to_uncache;
     457                 :            :         const bool m_test_accept;
     458                 :            :         /** Whether we allow transactions to replace mempool transactions by BIP125 rules. If false,
     459                 :            :          * any transaction spending the same inputs as a transaction in the mempool is considered
     460                 :            :          * a conflict. */
     461                 :            :         const bool m_allow_replacement;
     462                 :            :         /** When true, the mempool will not be trimmed when any transactions are submitted in
     463                 :            :          * Finalize(). Instead, limits should be enforced at the end to ensure the package is not
     464                 :            :          * partially submitted.
     465                 :            :          */
     466                 :            :         const bool m_package_submission;
     467                 :            :         /** When true, use package feerates instead of individual transaction feerates for fee-based
     468                 :            :          * policies such as mempool min fee and min relay fee.
     469                 :            :          */
     470                 :            :         const bool m_package_feerates;
     471                 :            : 
     472                 :            :         /** Parameters for single transaction mempool validation. */
     473                 :          0 :         static ATMPArgs SingleAccept(const CChainParams& chainparams, int64_t accept_time,
     474                 :            :                                      bool bypass_limits, std::vector<COutPoint>& coins_to_uncache,
     475                 :            :                                      bool test_accept) {
     476                 :          0 :             return ATMPArgs{/* m_chainparams */ chainparams,
     477                 :          0 :                             /* m_accept_time */ accept_time,
     478                 :          0 :                             /* m_bypass_limits */ bypass_limits,
     479                 :          0 :                             /* m_coins_to_uncache */ coins_to_uncache,
     480                 :          0 :                             /* m_test_accept */ test_accept,
     481                 :            :                             /* m_allow_replacement */ true,
     482                 :            :                             /* m_package_submission */ false,
     483                 :            :                             /* m_package_feerates */ false,
     484                 :            :             };
     485                 :            :         }
     486                 :            : 
     487                 :            :         /** Parameters for test package mempool validation through testmempoolaccept. */
     488                 :          0 :         static ATMPArgs PackageTestAccept(const CChainParams& chainparams, int64_t accept_time,
     489                 :            :                                           std::vector<COutPoint>& coins_to_uncache) {
     490                 :          0 :             return ATMPArgs{/* m_chainparams */ chainparams,
     491                 :          0 :                             /* m_accept_time */ accept_time,
     492                 :            :                             /* m_bypass_limits */ false,
     493                 :          0 :                             /* m_coins_to_uncache */ coins_to_uncache,
     494                 :          1 :                             /* m_test_accept */ true,
     495                 :            :                             /* m_allow_replacement */ false,
     496                 :            :                             /* m_package_submission */ false, // not submitting to mempool
     497                 :          1 :                             /* m_package_feerates */ false,
     498                 :            :             };
     499                 :            :         }
     500                 :            : 
     501                 :            :         /** Parameters for child-with-unconfirmed-parents package validation. */
     502                 :          0 :         static ATMPArgs PackageChildWithParents(const CChainParams& chainparams, int64_t accept_time,
     503                 :            :                                                 std::vector<COutPoint>& coins_to_uncache) {
     504                 :          0 :             return ATMPArgs{/* m_chainparams */ chainparams,
     505                 :          0 :                             /* m_accept_time */ accept_time,
     506                 :            :                             /* m_bypass_limits */ false,
     507                 :          0 :                             /* m_coins_to_uncache */ coins_to_uncache,
     508                 :            :                             /* m_test_accept */ false,
     509                 :            :                             /* m_allow_replacement */ false,
     510                 :            :                             /* m_package_submission */ true,
     511                 :            :                             /* m_package_feerates */ true,
     512                 :            :             };
     513                 :            :         }
     514                 :            : 
     515                 :            :         /** Parameters for a single transaction within a package. */
     516                 :          0 :         static ATMPArgs SingleInPackageAccept(const ATMPArgs& package_args) {
     517                 :          0 :             return ATMPArgs{/* m_chainparams */ package_args.m_chainparams,
     518                 :          0 :                             /* m_accept_time */ package_args.m_accept_time,
     519                 :            :                             /* m_bypass_limits */ false,
     520                 :          0 :                             /* m_coins_to_uncache */ package_args.m_coins_to_uncache,
     521                 :          0 :                             /* m_test_accept */ package_args.m_test_accept,
     522                 :            :                             /* m_allow_replacement */ true,
     523                 :            :                             /* m_package_submission */ true, // do not LimitMempoolSize in Finalize()
     524                 :            :                             /* m_package_feerates */ false, // only 1 transaction
     525                 :            :             };
     526                 :            :         }
     527                 :            : 
     528                 :            :     private:
     529                 :            :         // Private ctor to avoid exposing details to clients and allowing the possibility of
     530                 :            :         // mixing up the order of the arguments. Use static functions above instead.
     531                 :          0 :         ATMPArgs(const CChainParams& chainparams,
     532                 :            :                  int64_t accept_time,
     533                 :            :                  bool bypass_limits,
     534                 :            :                  std::vector<COutPoint>& coins_to_uncache,
     535                 :            :                  bool test_accept,
     536                 :            :                  bool allow_replacement,
     537                 :            :                  bool package_submission,
     538                 :            :                  bool package_feerates)
     539                 :          0 :             : m_chainparams{chainparams},
     540                 :          0 :               m_accept_time{accept_time},
     541                 :          0 :               m_bypass_limits{bypass_limits},
     542                 :          0 :               m_coins_to_uncache{coins_to_uncache},
     543                 :          0 :               m_test_accept{test_accept},
     544                 :          0 :               m_allow_replacement{allow_replacement},
     545                 :          0 :               m_package_submission{package_submission},
     546                 :          0 :               m_package_feerates{package_feerates}
     547                 :            :         {
     548                 :          0 :         }
     549                 :            :     };
     550                 :            : 
     551                 :            :     // Single transaction acceptance
     552                 :            :     MempoolAcceptResult AcceptSingleTransaction(const CTransactionRef& ptx, ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     553                 :            : 
     554                 :            :     /**
     555                 :            :     * Multiple transaction acceptance. Transactions may or may not be interdependent, but must not
     556                 :            :     * conflict with each other, and the transactions cannot already be in the mempool. Parents must
     557                 :            :     * come before children if any dependencies exist.
     558                 :            :     */
     559                 :            :     PackageMempoolAcceptResult AcceptMultipleTransactions(const std::vector<CTransactionRef>& txns, ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     560                 :            : 
     561                 :            :     /**
     562                 :            :      * Submission of a subpackage.
     563                 :            :      * If subpackage size == 1, calls AcceptSingleTransaction() with adjusted ATMPArgs to avoid
     564                 :            :      * package policy restrictions like no CPFP carve out (PackageMempoolChecks) and disabled RBF
     565                 :            :      * (m_allow_replacement), and creates a PackageMempoolAcceptResult wrapping the result.
     566                 :            :      *
     567                 :            :      * If subpackage size > 1, calls AcceptMultipleTransactions() with the provided ATMPArgs.
     568                 :            :      *
     569                 :            :      * Also cleans up all non-chainstate coins from m_view at the end.
     570                 :            :     */
     571                 :            :     PackageMempoolAcceptResult AcceptSubPackage(const std::vector<CTransactionRef>& subpackage, ATMPArgs& args)
     572                 :            :         EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
     573                 :            : 
     574                 :            :     /**
     575                 :            :      * Package (more specific than just multiple transactions) acceptance. Package must be a child
     576                 :            :      * with all of its unconfirmed parents, and topologically sorted.
     577                 :            :      */
     578                 :            :     PackageMempoolAcceptResult AcceptPackage(const Package& package, ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     579                 :            : 
     580                 :            : private:
     581                 :            :     // All the intermediate state that gets passed between the various levels
     582                 :            :     // of checking a given transaction.
     583                 :            :     struct Workspace {
     584         [ #  # ]:          0 :         explicit Workspace(const CTransactionRef& ptx) : m_ptx(ptx), m_hash(ptx->GetHash()) {}
     585                 :            :         /** Txids of mempool transactions that this transaction directly conflicts with. */
     586                 :            :         std::set<uint256> m_conflicts;
     587                 :            :         /** Iterators to mempool entries that this transaction directly conflicts with. */
     588                 :            :         CTxMemPool::setEntries m_iters_conflicting;
     589                 :            :         /** Iterators to all mempool entries that would be replaced by this transaction, including
     590                 :            :          * those it directly conflicts with and their descendants. */
     591                 :            :         CTxMemPool::setEntries m_all_conflicting;
     592                 :            :         /** All mempool ancestors of this transaction. */
     593                 :            :         CTxMemPool::setEntries m_ancestors;
     594                 :            :         /** Mempool entry constructed for this transaction. Constructed in PreChecks() but not
     595                 :            :          * inserted into the mempool until Finalize(). */
     596                 :            :         std::unique_ptr<CTxMemPoolEntry> m_entry;
     597                 :            :         /** Pointers to the transactions that have been removed from the mempool and replaced by
     598                 :            :          * this transaction, used to return to the MemPoolAccept caller. Only populated if
     599                 :            :          * validation is successful and the original transactions are removed. */
     600                 :            :         std::list<CTransactionRef> m_replaced_transactions;
     601                 :            : 
     602                 :            :         /** Virtual size of the transaction as used by the mempool, calculated using serialized size
     603                 :            :          * of the transaction and sigops. */
     604                 :            :         int64_t m_vsize;
     605                 :            :         /** Fees paid by this transaction: total input amounts subtracted by total output amounts. */
     606                 :            :         CAmount m_base_fees;
     607                 :          1 :         /** Base fees + any fee delta set by the user with prioritisetransaction. */
     608                 :            :         CAmount m_modified_fees;
     609                 :            :         /** Total modified fees of all transactions being replaced. */
     610                 :          1 :         CAmount m_conflicting_fees{0};
     611                 :            :         /** Total virtual size of all transactions being replaced. */
     612                 :          0 :         size_t m_conflicting_size{0};
     613                 :            : 
     614                 :            :         /** If we're doing package validation (i.e. m_package_feerates=true), the "effective"
     615                 :            :          * package feerate of this transaction is the total fees divided by the total size of
     616                 :            :          * transactions (which may include its ancestors and/or descendants). */
     617         [ #  # ]:          0 :         CFeeRate m_package_feerate{0};
     618                 :            : 
     619                 :            :         const CTransactionRef& m_ptx;
     620                 :            :         /** Txid. */
     621                 :            :         const uint256& m_hash;
     622                 :            :         TxValidationState m_state;
     623                 :            :         /** A temporary cache containing serialized transaction data for signature verification.
     624                 :            :          * Reused across PolicyScriptChecks and ConsensusScriptChecks. */
     625                 :            :         PrecomputedTransactionData m_precomputed_txdata;
     626                 :            :     };
     627                 :            : 
     628                 :            :     // Run the policy checks on a given transaction, excluding any script checks.
     629                 :            :     // Looks up inputs, calculates feerate, considers replacement, evaluates
     630                 :            :     // package limits, etc. As this function can be invoked for "free" by a peer,
     631                 :            :     // only tests that are fast should be done here (to avoid CPU DoS).
     632                 :            :     bool PreChecks(ATMPArgs& args, Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
     633                 :            : 
     634                 :            :     // Run checks for mempool replace-by-fee.
     635                 :            :     bool ReplacementChecks(Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
     636                 :            : 
     637                 :            :     // Enforce package mempool ancestor/descendant limits (distinct from individual
     638                 :            :     // ancestor/descendant limits done in PreChecks).
     639                 :            :     bool PackageMempoolChecks(const std::vector<CTransactionRef>& txns,
     640                 :            :                               int64_t total_vsize,
     641                 :            :                               PackageValidationState& package_state) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
     642                 :            : 
     643                 :            :     // Run the script checks using our policy flags. As this can be slow, we should
     644                 :            :     // only invoke this on transactions that have otherwise passed policy checks.
     645                 :            :     bool PolicyScriptChecks(const ATMPArgs& args, Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
     646                 :            : 
     647                 :            :     // Re-run the script checks, using consensus flags, and try to cache the
     648                 :            :     // result in the scriptcache. This should be done after
     649                 :            :     // PolicyScriptChecks(). This requires that all inputs either be in our
     650                 :            :     // utxo set or in the mempool.
     651                 :            :     bool ConsensusScriptChecks(const ATMPArgs& args, Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
     652                 :            : 
     653                 :            :     // Try to add the transaction to the mempool, removing any conflicts first.
     654                 :            :     // Returns true if the transaction is in the mempool after any size
     655                 :            :     // limiting is performed, false otherwise.
     656                 :            :     bool Finalize(const ATMPArgs& args, Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
     657                 :            : 
     658                 :            :     // Submit all transactions to the mempool and call ConsensusScriptChecks to add to the script
     659                 :            :     // cache - should only be called after successful validation of all transactions in the package.
     660                 :            :     // Does not call LimitMempoolSize(), so mempool max_size_bytes may be temporarily exceeded.
     661                 :            :     bool SubmitPackage(const ATMPArgs& args, std::vector<Workspace>& workspaces, PackageValidationState& package_state,
     662                 :            :                        std::map<uint256, MempoolAcceptResult>& results)
     663                 :            :          EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
     664                 :            : 
     665                 :            :     // Compare a package's feerate against minimum allowed.
     666                 :          0 :     bool CheckFeeRate(size_t package_size, CAmount package_fee, TxValidationState& state) EXCLUSIVE_LOCKS_REQUIRED(::cs_main, m_pool.cs)
     667                 :            :     {
     668                 :          0 :         AssertLockHeld(::cs_main);
     669                 :          0 :         AssertLockHeld(m_pool.cs);
     670                 :          0 :         CAmount mempoolRejectFee = m_pool.GetMinFee().GetFee(package_size);
     671   [ #  #  #  # ]:          0 :         if (mempoolRejectFee > 0 && package_fee < mempoolRejectFee) {
     672   [ #  #  #  #  :          0 :             return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "mempool min fee not met", strprintf("%d < %d", package_fee, mempoolRejectFee));
                   #  # ]
     673                 :            :         }
     674                 :            : 
     675         [ #  # ]:          0 :         if (package_fee < m_pool.m_min_relay_feerate.GetFee(package_size)) {
     676   [ #  #  #  # ]:          0 :             return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "min relay fee not met",
     677   [ #  #  #  # ]:          0 :                                  strprintf("%d < %d", package_fee, m_pool.m_min_relay_feerate.GetFee(package_size)));
     678                 :            :         }
     679                 :          0 :         return true;
     680                 :          0 :     }
     681                 :            : 
     682                 :            : private:
     683                 :            :     CTxMemPool& m_pool;
     684                 :            :     CCoinsViewCache m_view;
     685                 :            :     CCoinsViewMemPool m_viewmempool;
     686                 :            :     CCoinsView m_dummy;
     687                 :            : 
     688                 :            :     Chainstate& m_active_chainstate;
     689                 :            : 
     690                 :            :     /** Whether the transaction(s) would replace any mempool transactions. If so, RBF rules apply. */
     691                 :          0 :     bool m_rbf{false};
     692                 :            : };
     693                 :            : 
     694                 :          0 : bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
     695                 :            : {
     696                 :          0 :     AssertLockHeld(cs_main);
     697                 :          0 :     AssertLockHeld(m_pool.cs);
     698                 :          0 :     const CTransactionRef& ptx = ws.m_ptx;
     699                 :          0 :     const CTransaction& tx = *ws.m_ptx;
     700                 :          0 :     const uint256& hash = ws.m_hash;
     701                 :            : 
     702                 :            :     // Copy/alias what we need out of args
     703                 :          0 :     const int64_t nAcceptTime = args.m_accept_time;
     704                 :          0 :     const bool bypass_limits = args.m_bypass_limits;
     705                 :          0 :     std::vector<COutPoint>& coins_to_uncache = args.m_coins_to_uncache;
     706                 :            : 
     707                 :            :     // Alias what we need out of ws
     708                 :          0 :     TxValidationState& state = ws.m_state;
     709                 :          0 :     std::unique_ptr<CTxMemPoolEntry>& entry = ws.m_entry;
     710                 :            : 
     711         [ #  # ]:          0 :     if (!CheckTransaction(tx, state)) {
     712                 :          0 :         return false; // state filled in by CheckTransaction
     713                 :            :     }
     714                 :            : 
     715                 :            :     // Coinbase is only valid in a block, not as a loose transaction
     716         [ #  # ]:          0 :     if (tx.IsCoinBase())
     717   [ #  #  #  #  :          0 :         return state.Invalid(TxValidationResult::TX_CONSENSUS, "coinbase");
                   #  # ]
     718                 :            : 
     719                 :            :     // Rather not work on nonstandard transactions (unless -testnet/-regtest)
     720                 :          0 :     std::string reason;
     721   [ #  #  #  #  :          0 :     if (m_pool.m_require_standard && !IsStandardTx(tx, m_pool.m_max_datacarrier_bytes, m_pool.m_permit_bare_multisig, m_pool.m_dust_relay_feerate, reason)) {
                   #  # ]
     722   [ #  #  #  # ]:          0 :         return state.Invalid(TxValidationResult::TX_NOT_STANDARD, reason);
     723                 :            :     }
     724                 :            : 
     725                 :            :     // Transactions smaller than 65 non-witness bytes are not relayed to mitigate CVE-2017-12842.
     726   [ #  #  #  # ]:          0 :     if (::GetSerializeSize(tx, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS) < MIN_STANDARD_TX_NONWITNESS_SIZE)
     727   [ #  #  #  #  :          0 :         return state.Invalid(TxValidationResult::TX_NOT_STANDARD, "tx-size-small");
                   #  # ]
     728                 :            : 
     729                 :            :     // Only accept nLockTime-using transactions that can be mined in the next
     730                 :            :     // block; we don't want our mempool filled up with transactions that can't
     731                 :            :     // be mined yet.
     732   [ #  #  #  #  :          0 :     if (!CheckFinalTxAtTip(*Assert(m_active_chainstate.m_chain.Tip()), tx)) {
                   #  # ]
     733   [ #  #  #  #  :          0 :         return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "non-final");
                   #  # ]
     734                 :            :     }
     735                 :            : 
     736   [ #  #  #  #  :          0 :     if (m_pool.exists(GenTxid::Wtxid(tx.GetWitnessHash()))) {
             #  #  #  # ]
     737                 :            :         // Exact transaction already exists in the mempool.
     738   [ #  #  #  #  :          0 :         return state.Invalid(TxValidationResult::TX_CONFLICT, "txn-already-in-mempool");
                   #  # ]
     739   [ #  #  #  #  :          0 :     } else if (m_pool.exists(GenTxid::Txid(tx.GetHash()))) {
                   #  # ]
     740                 :            :         // Transaction with the same non-witness data but different witness (same txid, different
     741                 :            :         // wtxid) already exists in the mempool.
     742   [ #  #  #  #  :          0 :         return state.Invalid(TxValidationResult::TX_CONFLICT, "txn-same-nonwitness-data-in-mempool");
                   #  # ]
     743                 :            :     }
     744                 :            : 
     745                 :            :     // Check for conflicts with in-memory transactions
     746         [ #  # ]:          0 :     for (const CTxIn &txin : tx.vin)
     747                 :            :     {
     748         [ #  # ]:          0 :         const CTransaction* ptxConflicting = m_pool.GetConflictTx(txin.prevout);
     749         [ #  # ]:          0 :         if (ptxConflicting) {
     750         [ #  # ]:          0 :             if (!args.m_allow_replacement) {
     751                 :            :                 // Transaction conflicts with a mempool tx, but we're not allowing replacements.
     752   [ #  #  #  #  :          0 :                 return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "bip125-replacement-disallowed");
                   #  # ]
     753                 :            :             }
     754   [ #  #  #  # ]:          0 :             if (!ws.m_conflicts.count(ptxConflicting->GetHash()))
     755                 :            :             {
     756                 :            :                 // Transactions that don't explicitly signal replaceability are
     757                 :            :                 // *not* replaceable with the current logic, even if one of their
     758                 :            :                 // unconfirmed ancestors signals replaceability. This diverges
     759                 :            :                 // from BIP125's inherited signaling description (see CVE-2021-31876).
     760                 :            :                 // Applications relying on first-seen mempool behavior should
     761                 :            :                 // check all unconfirmed ancestors; otherwise an opt-in ancestor
     762                 :            :                 // might be replaced, causing removal of this descendant.
     763         [ +  - ]:          1 :                 //
     764         [ +  - ]:          1 :                 // If replaceability signaling is ignored due to node setting,
     765                 :            :                 // replacement is always allowed.
     766   [ #  #  #  #  :          0 :                 if (!m_pool.m_full_rbf && !SignalsOptInRBF(*ptxConflicting)) {
                   #  # ]
     767   [ #  #  #  #  :          0 :                     return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "txn-mempool-conflict");
                   #  # ]
     768                 :            :                 }
     769                 :            : 
     770         [ #  # ]:          0 :                 ws.m_conflicts.insert(ptxConflicting->GetHash());
     771                 :          0 :             }
     772                 :          0 :         }
     773                 :            :     }
     774                 :            : 
     775         [ #  # ]:          0 :     m_view.SetBackend(m_viewmempool);
     776                 :            : 
     777         [ #  # ]:          0 :     const CCoinsViewCache& coins_cache = m_active_chainstate.CoinsTip();
     778                 :            :     // do all inputs exist?
     779         [ #  # ]:          0 :     for (const CTxIn& txin : tx.vin) {
     780   [ #  #  #  # ]:          0 :         if (!coins_cache.HaveCoinInCache(txin.prevout)) {
     781         [ #  # ]:          0 :             coins_to_uncache.push_back(txin.prevout);
     782                 :          0 :         }
     783                 :            : 
     784                 :            :         // Note: this call may add txin.prevout to the coins cache
     785                 :            :         // (coins_cache.cacheCoins) by way of FetchCoin(). It should be removed
     786                 :            :         // later (via coins_to_uncache) if this tx turns out to be invalid.
     787   [ #  #  #  # ]:          0 :         if (!m_view.HaveCoin(txin.prevout)) {
     788                 :            :             // Are inputs missing because we already have the tx?
     789         [ #  # ]:          0 :             for (size_t out = 0; out < tx.vout.size(); out++) {
     790                 :            :                 // Optimistically just do efficient check of cache for outputs
     791   [ #  #  #  #  :          0 :                 if (coins_cache.HaveCoinInCache(COutPoint(hash, out))) {
                   #  # ]
     792   [ #  #  #  #  :          0 :                     return state.Invalid(TxValidationResult::TX_CONFLICT, "txn-already-known");
                   #  # ]
     793                 :            :                 }
     794                 :          0 :             }
     795                 :            :             // Otherwise assume this might be an orphan tx for which we just haven't seen parents yet
     796   [ #  #  #  #  :          0 :             return state.Invalid(TxValidationResult::TX_MISSING_INPUTS, "bad-txns-inputs-missingorspent");
                   #  # ]
     797                 :            :         }
     798                 :            :     }
     799                 :            : 
     800                 :            :     // This is const, but calls into the back end CoinsViews. The CCoinsViewDB at the bottom of the
     801                 :            :     // hierarchy brings the best block into scope. See CCoinsViewDB::GetBestBlock().
     802         [ #  # ]:          0 :     m_view.GetBestBlock();
     803                 :            : 
     804                 :            :     // we have all inputs cached now, so switch back to dummy (to protect
     805                 :            :     // against bugs where we pull more inputs from disk that miss being added
     806                 :            :     // to coins_to_uncache)
     807         [ #  # ]:          0 :     m_view.SetBackend(m_dummy);
     808                 :            : 
     809   [ #  #  #  #  :          0 :     assert(m_active_chainstate.m_blockman.LookupBlockIndex(m_view.GetBestBlock()) == m_active_chainstate.m_chain.Tip());
                   #  # ]
     810                 :            : 
     811                 :            :     // Only accept BIP68 sequence locked transactions that can be mined in the next
     812                 :            :     // block; we don't want our mempool filled up with transactions that can't
     813                 :            :     // be mined yet.
     814                 :            :     // Pass in m_view which has all of the relevant inputs cached. Note that, since m_view's
     815                 :            :     // backend was removed, it no longer pulls coins from the mempool.
     816         [ #  # ]:          0 :     const std::optional<LockPoints> lock_points{CalculateLockPointsAtTip(m_active_chainstate.m_chain.Tip(), m_view, tx)};
     817   [ #  #  #  #  :          0 :     if (!lock_points.has_value() || !CheckSequenceLocksAtTip(m_active_chainstate.m_chain.Tip(), *lock_points)) {
             #  #  #  # ]
     818   [ #  #  #  #  :          0 :         return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "non-BIP68-final");
                   #  # ]
     819                 :            :     }
     820                 :            : 
     821                 :            :     // The mempool holds txs for the next block, so pass height+1 to CheckTxInputs
     822   [ #  #  #  # ]:          0 :     if (!Consensus::CheckTxInputs(tx, state, m_view, m_active_chainstate.m_chain.Height() + 1, ws.m_base_fees)) {
     823                 :          0 :         return false; // state filled in by CheckTxInputs
     824                 :            :     }
     825                 :            : 
     826   [ #  #  #  #  :          0 :     if (m_pool.m_require_standard && !AreInputsStandard(tx, m_view)) {
                   #  # ]
     827   [ #  #  #  #  :          0 :         return state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs");
                   #  # ]
     828                 :            :     }
     829                 :            : 
     830                 :            :     // Check for non-standard witnesses.
     831   [ #  #  #  #  :          0 :     if (tx.HasWitness() && m_pool.m_require_standard && !IsWitnessStandard(tx, m_view)) {
          #  #  #  #  #  
                      # ]
     832   [ #  #  #  #  :          0 :         return state.Invalid(TxValidationResult::TX_WITNESS_MUTATED, "bad-witness-nonstandard");
                   #  # ]
     833                 :            :     }
     834                 :            : 
     835         [ #  # ]:          0 :     int64_t nSigOpsCost = GetTransactionSigOpCost(tx, m_view, STANDARD_SCRIPT_VERIFY_FLAGS);
     836                 :            : 
     837                 :            :     // ws.m_modified_fees includes any fee deltas from PrioritiseTransaction
     838                 :          0 :     ws.m_modified_fees = ws.m_base_fees;
     839         [ #  # ]:          0 :     m_pool.ApplyDelta(hash, ws.m_modified_fees);
     840                 :            : 
     841                 :            :     // Keep track of transactions that spend a coinbase, which we re-scan
     842                 :            :     // during reorgs to ensure COINBASE_MATURITY is still met.
     843                 :          0 :     bool fSpendsCoinbase = false;
     844         [ #  # ]:          0 :     for (const CTxIn &txin : tx.vin) {
     845         [ #  # ]:          0 :         const Coin &coin = m_view.AccessCoin(txin.prevout);
     846   [ #  #  #  # ]:          0 :         if (coin.IsCoinBase()) {
     847                 :          0 :             fSpendsCoinbase = true;
     848                 :          0 :             break;
     849                 :            :         }
     850                 :            :     }
     851                 :            : 
     852                 :            :     // Set entry_sequence to 0 when bypass_limits is used; this allows txs from a block
     853                 :            :     // reorg to be marked earlier than any child txs that were already in the mempool.
     854   [ #  #  #  # ]:          0 :     const uint64_t entry_sequence = bypass_limits ? 0 : m_pool.GetSequence();
     855   [ #  #  #  # ]:          0 :     entry.reset(new CTxMemPoolEntry(ptx, ws.m_base_fees, nAcceptTime, m_active_chainstate.m_chain.Height(), entry_sequence,
     856         [ #  # ]:          0 :                                     fSpendsCoinbase, nSigOpsCost, lock_points.value()));
     857         [ #  # ]:          0 :     ws.m_vsize = entry->GetTxSize();
     858                 :            : 
     859         [ #  # ]:          0 :     if (nSigOpsCost > MAX_STANDARD_TX_SIGOPS_COST)
     860   [ #  #  #  # ]:          0 :         return state.Invalid(TxValidationResult::TX_NOT_STANDARD, "bad-txns-too-many-sigops",
     861         [ #  # ]:          1 :                 strprintf("%d", nSigOpsCost));
     862                 :            : 
     863                 :          1 :     // No individual transactions are allowed below the min relay feerate except from disconnected blocks.
     864                 :            :     // This requirement, unlike CheckFeeRate, cannot be bypassed using m_package_feerates because,
     865                 :            :     // while a tx could be package CPFP'd when entering the mempool, we do not have a DoS-resistant
     866                 :            :     // method of ensuring the tx remains bumped. For example, the fee-bumping child could disappear
     867                 :            :     // due to a replacement.
     868   [ #  #  #  #  :          0 :     if (!bypass_limits && ws.m_modified_fees < m_pool.m_min_relay_feerate.GetFee(ws.m_vsize)) {
                   #  # ]
     869   [ #  #  #  # ]:          0 :         return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "min relay fee not met",
     870   [ #  #  #  # ]:          0 :                              strprintf("%d < %d", ws.m_modified_fees, m_pool.m_min_relay_feerate.GetFee(ws.m_vsize)));
     871                 :            :     }
     872                 :            :     // No individual transactions are allowed below the mempool min feerate except from disconnected
     873                 :            :     // blocks and transactions in a package. Package transactions will be checked using package
     874                 :            :     // feerate later.
     875   [ #  #  #  #  :          0 :     if (!bypass_limits && !args.m_package_feerates && !CheckFeeRate(ws.m_vsize, ws.m_modified_fees, state)) return false;
             #  #  #  # ]
     876                 :            : 
     877         [ #  # ]:          0 :     ws.m_iters_conflicting = m_pool.GetIterSet(ws.m_conflicts);
     878                 :            : 
     879                 :            :     // Note that these modifications are only applicable to single transaction scenarios;
     880                 :            :     // carve-outs and package RBF are disabled for multi-transaction evaluations.
     881                 :          0 :     CTxMemPool::Limits maybe_rbf_limits = m_pool.m_limits;
     882                 :            : 
     883                 :            :     // Calculate in-mempool ancestors, up to a limit.
     884         [ #  # ]:          0 :     if (ws.m_conflicts.size() == 1) {
     885                 :            :         // In general, when we receive an RBF transaction with mempool conflicts, we want to know whether we
     886         [ +  - ]:          1 :         // would meet the chain limits after the conflicts have been removed. However, there isn't a practical
     887                 :            :         // way to do this short of calculating the ancestor and descendant sets with an overlay cache of
     888                 :            :         // changed mempool entries. Due to both implementation and runtime complexity concerns, this isn't
     889                 :            :         // very realistic, thus we only ensure a limited set of transactions are RBF'able despite mempool
     890                 :            :         // conflicts here. Importantly, we need to ensure that some transactions which were accepted using
     891                 :            :         // the below carve-out are able to be RBF'ed, without impacting the security the carve-out provides
     892                 :            :         // for off-chain contract systems (see link in the comment below).
     893                 :            :         //
     894                 :            :         // Specifically, the subset of RBF transactions which we allow despite chain limits are those which
     895                 :            :         // conflict directly with exactly one other transaction (but may evict children of said transaction),
     896                 :            :         // and which are not adding any new mempool dependencies. Note that the "no new mempool dependencies"
     897                 :            :         // check is accomplished later, so we don't bother doing anything about it here, but if our
     898                 :            :         // policy changes, we may need to move that check to here instead of removing it wholesale.
     899                 :            :         //
     900                 :            :         // Such transactions are clearly not merging any existing packages, so we are only concerned with
     901                 :            :         // ensuring that (a) no package is growing past the package size (not count) limits and (b) we are
     902                 :            :         // not allowing something to effectively use the (below) carve-out spot when it shouldn't be allowed
     903                 :            :         // to.
     904                 :            :         //
     905                 :            :         // To check these we first check if we meet the RBF criteria, above, and increment the descendant
     906                 :          1 :         // limits by the direct conflict and its descendants (as these are recalculated in
     907                 :            :         // CalculateMempoolAncestors by assuming the new transaction being added is a new descendant, with no
     908                 :            :         // removals, of each parent's existing dependent set). The ancestor count limits are unmodified (as
     909                 :            :         // the ancestor limits should be the same for both our new transaction and any conflicts).
     910                 :            :         // We don't bother incrementing m_limit_descendants by the full removal count as that limit never comes
     911                 :            :         // into force here (as we're only adding a single transaction).
     912         [ #  # ]:          0 :         assert(ws.m_iters_conflicting.size() == 1);
     913                 :          0 :         CTxMemPool::txiter conflict = *ws.m_iters_conflicting.begin();
     914                 :            : 
     915                 :          0 :         maybe_rbf_limits.descendant_count += 1;
     916   [ #  #  #  # ]:          0 :         maybe_rbf_limits.descendant_size_vbytes += conflict->GetSizeWithDescendants();
     917                 :          0 :     }
     918                 :            : 
     919   [ #  #  #  # ]:          0 :     auto ancestors{m_pool.CalculateMemPoolAncestors(*entry, maybe_rbf_limits)};
     920         [ #  # ]:          0 :     if (!ancestors) {
     921                 :            :         // If CalculateMemPoolAncestors fails second time, we want the original error string.
     922                 :            :         // Contracting/payment channels CPFP carve-out:
     923                 :            :         // If the new transaction is relatively small (up to 40k weight)
     924                 :            :         // and has at most one ancestor (ie ancestor limit of 2, including
     925                 :            :         // the new transaction), allow it if its parent has exactly the
     926                 :            :         // descendant limit descendants.
     927                 :            :         //
     928                 :            :         // This allows protocols which rely on distrusting counterparties
     929                 :            :         // being able to broadcast descendants of an unconfirmed transaction
     930                 :            :         // to be secure by simply only having two immediately-spendable
     931                 :            :         // outputs - one for each counterparty. For more info on the uses for
     932                 :            :         // this, see https://lists.linuxfoundation.org/pipermail/bitcoin-dev/2018-November/016518.html
     933                 :          0 :         CTxMemPool::Limits cpfp_carve_out_limits{
     934                 :            :             .ancestor_count = 2,
     935                 :          0 :             .ancestor_size_vbytes = maybe_rbf_limits.ancestor_size_vbytes,
     936                 :          0 :             .descendant_count = maybe_rbf_limits.descendant_count + 1,
     937                 :          0 :             .descendant_size_vbytes = maybe_rbf_limits.descendant_size_vbytes + EXTRA_DESCENDANT_TX_SIZE_LIMIT,
     938                 :            :         };
     939         [ #  # ]:          0 :         const auto error_message{util::ErrorString(ancestors).original};
     940         [ #  # ]:          0 :         if (ws.m_vsize > EXTRA_DESCENDANT_TX_SIZE_LIMIT) {
     941   [ #  #  #  # ]:          0 :             return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-long-mempool-chain", error_message);
     942                 :            :         }
     943   [ #  #  #  # ]:          0 :         ancestors = m_pool.CalculateMemPoolAncestors(*entry, cpfp_carve_out_limits);
     944   [ #  #  #  #  :          0 :         if (!ancestors) return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-long-mempool-chain", error_message);
                   #  # ]
     945         [ #  # ]:          0 :     }
     946                 :            : 
     947   [ #  #  #  # ]:          0 :     ws.m_ancestors = *ancestors;
     948                 :            : 
     949                 :          1 :     // A transaction that spends outputs that would be replaced by it is invalid. Now
     950                 :            :     // that we have the set of all ancestors we can detect this
     951                 :            :     // pathological case by making sure ws.m_conflicts and ws.m_ancestors don't
     952                 :            :     // intersect.
     953   [ #  #  #  #  :          0 :     if (const auto err_string{EntriesAndTxidsDisjoint(ws.m_ancestors, ws.m_conflicts, hash)}) {
                   #  # ]
     954                 :            :         // We classify this as a consensus error because a transaction depending on something it
     955                 :            :         // conflicts with would be inconsistent.
     956   [ #  #  #  #  :          1 :         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-spends-conflicting-tx", *err_string);
                   #  # ]
     957                 :            :     }
     958                 :          1 : 
     959                 :          0 :     m_rbf = !ws.m_conflicts.empty();
     960         [ -  + ]:          1 :     return true;
     961                 :          0 : }
     962                 :            : 
     963                 :          0 : bool MemPoolAccept::ReplacementChecks(Workspace& ws)
     964                 :            : {
     965                 :          0 :     AssertLockHeld(cs_main);
     966                 :          0 :     AssertLockHeld(m_pool.cs);
     967                 :            : 
     968                 :          0 :     const CTransaction& tx = *ws.m_ptx;
     969                 :          0 :     const uint256& hash = ws.m_hash;
     970                 :          0 :     TxValidationState& state = ws.m_state;
     971                 :            : 
     972                 :          0 :     CFeeRate newFeeRate(ws.m_modified_fees, ws.m_vsize);
     973                 :            :     // Enforce Rule #6. The replacement transaction must have a higher feerate than its direct conflicts.
     974                 :            :     // - The motivation for this check is to ensure that the replacement transaction is preferable for
     975                 :            :     //   block-inclusion, compared to what would be removed from the mempool.
     976                 :            :     // - This logic predates ancestor feerate-based transaction selection, which is why it doesn't
     977                 :            :     //   consider feerates of descendants.
     978                 :            :     // - Note: Ancestor feerate-based transaction selection has made this comparison insufficient to
     979                 :            :     //   guarantee that this is incentive-compatible for miners, because it is possible for a
     980                 :            :     //   descendant transaction of a direct conflict to pay a higher feerate than the transaction that
     981                 :            :     //   might replace them, under these rules.
     982   [ #  #  #  # ]:          0 :     if (const auto err_string{PaysMoreThanConflicts(ws.m_iters_conflicting, newFeeRate, hash)}) {
     983   [ #  #  #  # ]:          0 :         return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "insufficient fee", *err_string);
     984                 :            :     }
     985                 :            : 
     986                 :            :     // Calculate all conflicting entries and enforce Rule #5.
     987   [ #  #  #  # ]:          0 :     if (const auto err_string{GetEntriesForConflicts(tx, m_pool, ws.m_iters_conflicting, ws.m_all_conflicting)}) {
     988         [ #  # ]:          0 :         return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY,
     989         [ #  # ]:          0 :                              "too many potential replacements", *err_string);
     990                 :            :     }
     991                 :            :     // Enforce Rule #2.
     992   [ #  #  #  # ]:          0 :     if (const auto err_string{HasNoNewUnconfirmed(tx, m_pool, ws.m_iters_conflicting)}) {
     993         [ #  # ]:          0 :         return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY,
     994         [ #  # ]:          1 :                              "replacement-adds-unconfirmed", *err_string);
     995                 :            :     }
     996                 :            :     // Check if it's economically rational to mine this transaction rather than the ones it
     997                 :            :     // replaces and pays for its own relay fees. Enforce Rules #3 and #4.
     998         [ #  # ]:          1 :     for (CTxMemPool::txiter it : ws.m_all_conflicting) {
     999                 :          0 :         ws.m_conflicting_fees += it->GetModifiedFee();
    1000                 :          0 :         ws.m_conflicting_size += it->GetTxSize();
    1001                 :            :     }
    1002   [ #  #  #  #  :          1 :     if (const auto err_string{PaysForRBF(ws.m_conflicting_fees, ws.m_modified_fees, ws.m_vsize,
                   #  # ]
    1003                 :          0 :                                          m_pool.m_incremental_relay_feerate, hash)}) {
    1004   [ #  #  #  # ]:          0 :         return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "insufficient fee", *err_string);
    1005                 :            :     }
    1006                 :          0 :     return true;
    1007                 :          0 : }
    1008                 :            : 
    1009                 :          0 : bool MemPoolAccept::PackageMempoolChecks(const std::vector<CTransactionRef>& txns,
    1010                 :            :                                          const int64_t total_vsize,
    1011                 :            :                                          PackageValidationState& package_state)
    1012                 :            : {
    1013                 :          0 :     AssertLockHeld(cs_main);
    1014                 :          0 :     AssertLockHeld(m_pool.cs);
    1015                 :            : 
    1016                 :            :     // CheckPackageLimits expects the package transactions to not already be in the mempool.
    1017         [ #  # ]:          0 :     assert(std::all_of(txns.cbegin(), txns.cend(), [this](const auto& tx)
    1018                 :            :                        { return !m_pool.exists(GenTxid::Txid(tx->GetHash()));}));
    1019                 :            : 
    1020                 :          0 :     std::string err_string;
    1021   [ #  #  #  # ]:          0 :     if (!m_pool.CheckPackageLimits(txns, total_vsize, err_string)) {
    1022                 :            :         // This is a package-wide error, separate from an individual transaction error.
    1023   [ #  #  #  # ]:          0 :         return package_state.Invalid(PackageValidationResult::PCKG_POLICY, "package-mempool-limits", err_string);
    1024                 :            :     }
    1025                 :          0 :    return true;
    1026                 :          0 : }
    1027                 :            : 
    1028                 :          0 : bool MemPoolAccept::PolicyScriptChecks(const ATMPArgs& args, Workspace& ws)
    1029                 :            : {
    1030                 :          0 :     AssertLockHeld(cs_main);
    1031                 :          0 :     AssertLockHeld(m_pool.cs);
    1032                 :          0 :     const CTransaction& tx = *ws.m_ptx;
    1033                 :          0 :     TxValidationState& state = ws.m_state;
    1034                 :            : 
    1035                 :          0 :     constexpr unsigned int scriptVerifyFlags = STANDARD_SCRIPT_VERIFY_FLAGS;
    1036                 :            : 
    1037                 :            :     // Check input scripts and signatures.
    1038                 :            :     // This is done last to help prevent CPU exhaustion denial-of-service attacks.
    1039         [ #  # ]:          0 :     if (!CheckInputScripts(tx, state, m_view, scriptVerifyFlags, true, false, ws.m_precomputed_txdata)) {
    1040                 :            :         // SCRIPT_VERIFY_CLEANSTACK requires SCRIPT_VERIFY_WITNESS, so we
    1041                 :            :         // need to turn both off, and compare against just turning off CLEANSTACK
    1042                 :            :         // to see if the failure is specifically due to witness validation.
    1043                 :          0 :         TxValidationState state_dummy; // Want reported failures to be from first CheckInputScripts
    1044   [ #  #  #  #  :          0 :         if (!tx.HasWitness() && CheckInputScripts(tx, state_dummy, m_view, scriptVerifyFlags & ~(SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_CLEANSTACK), true, false, ws.m_precomputed_txdata) &&
          #  #  #  #  #  
                      # ]
    1045         [ #  # ]:          0 :                 !CheckInputScripts(tx, state_dummy, m_view, scriptVerifyFlags & ~SCRIPT_VERIFY_CLEANSTACK, true, false, ws.m_precomputed_txdata)) {
    1046                 :            :             // Only the witness is missing, so the transaction itself may be fine.
    1047         [ #  # ]:          0 :             state.Invalid(TxValidationResult::TX_WITNESS_STRIPPED,
    1048   [ #  #  #  # ]:          0 :                     state.GetRejectReason(), state.GetDebugMessage());
    1049                 :          0 :         }
    1050                 :          0 :         return false; // state filled in by CheckInputScripts
    1051                 :          0 :     }
    1052                 :            : 
    1053                 :          0 :     return true;
    1054                 :          0 : }
    1055                 :            : 
    1056                 :          0 : bool MemPoolAccept::ConsensusScriptChecks(const ATMPArgs& args, Workspace& ws)
    1057                 :            : {
    1058                 :          0 :     AssertLockHeld(cs_main);
    1059                 :          0 :     AssertLockHeld(m_pool.cs);
    1060                 :          0 :     const CTransaction& tx = *ws.m_ptx;
    1061                 :          0 :     const uint256& hash = ws.m_hash;
    1062                 :          0 :     TxValidationState& state = ws.m_state;
    1063                 :            : 
    1064                 :            :     // Check again against the current block tip's script verification
    1065                 :            :     // flags to cache our script execution flags. This is, of course,
    1066                 :            :     // useless if the next block has different script flags from the
    1067                 :            :     // previous one, but because the cache tracks script flags for us it
    1068                 :            :     // will auto-invalidate and we'll just have a few blocks of extra
    1069                 :            :     // misses on soft-fork activation.
    1070                 :            :     //
    1071                 :            :     // This is also useful in case of bugs in the standard flags that cause
    1072                 :            :     // transactions to pass as valid when they're actually invalid. For
    1073                 :            :     // instance the STRICTENC flag was incorrectly allowing certain
    1074                 :            :     // CHECKSIG NOT scripts to pass, even though they were invalid.
    1075                 :            :     //
    1076                 :            :     // There is a similar check in CreateNewBlock() to prevent creating
    1077                 :            :     // invalid blocks (using TestBlockValidity), however allowing such
    1078                 :            :     // transactions into the mempool can be exploited as a DoS attack.
    1079                 :          0 :     unsigned int currentBlockScriptVerifyFlags{GetBlockScriptFlags(*m_active_chainstate.m_chain.Tip(), m_active_chainstate.m_chainman)};
    1080   [ #  #  #  # ]:          0 :     if (!CheckInputsFromMempoolAndCache(tx, state, m_view, m_pool, currentBlockScriptVerifyFlags,
    1081                 :          0 :                                         ws.m_precomputed_txdata, m_active_chainstate.CoinsTip())) {
    1082   [ #  #  #  #  :          0 :         LogPrintf("BUG! PLEASE REPORT THIS! CheckInputScripts failed against latest-block but not STANDARD flags %s, %s\n", hash.ToString(), state.ToString());
          #  #  #  #  #  
                      # ]
    1083                 :          0 :         return Assume(false);
    1084                 :            :     }
    1085                 :            : 
    1086                 :          0 :     return true;
    1087                 :          0 : }
    1088                 :            : 
    1089                 :          0 : bool MemPoolAccept::Finalize(const ATMPArgs& args, Workspace& ws)
    1090                 :            : {
    1091                 :          0 :     AssertLockHeld(cs_main);
    1092                 :          0 :     AssertLockHeld(m_pool.cs);
    1093                 :          0 :     const CTransaction& tx = *ws.m_ptx;
    1094                 :          0 :     const uint256& hash = ws.m_hash;
    1095                 :          0 :     TxValidationState& state = ws.m_state;
    1096                 :          0 :     const bool bypass_limits = args.m_bypass_limits;
    1097                 :            : 
    1098                 :          0 :     std::unique_ptr<CTxMemPoolEntry>& entry = ws.m_entry;
    1099                 :            : 
    1100                 :            :     // Remove conflicting transactions from the mempool
    1101         [ #  # ]:          0 :     for (CTxMemPool::txiter it : ws.m_all_conflicting)
    1102                 :            :     {
    1103   [ #  #  #  #  :          0 :         LogPrint(BCLog::MEMPOOL, "replacing tx %s (wtxid=%s) with %s (wtxid=%s) for %s additional fees, %d delta bytes\n",
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
    1104                 :            :                 it->GetTx().GetHash().ToString(),
    1105                 :            :                 it->GetTx().GetWitnessHash().ToString(),
    1106                 :            :                 hash.ToString(),
    1107                 :            :                 tx.GetWitnessHash().ToString(),
    1108                 :            :                 FormatMoney(ws.m_modified_fees - ws.m_conflicting_fees),
    1109                 :            :                 (int)entry->GetTxSize() - (int)ws.m_conflicting_size);
    1110                 :            :         TRACE7(mempool, replaced,
    1111                 :            :                 it->GetTx().GetHash().data(),
    1112                 :            :                 it->GetTxSize(),
    1113                 :            :                 it->GetFee(),
    1114                 :            :                 std::chrono::duration_cast<std::chrono::duration<std::uint64_t>>(it->GetTime()).count(),
    1115                 :            :                 hash.data(),
    1116                 :            :                 entry->GetTxSize(),
    1117                 :            :                 entry->GetFee()
    1118                 :            :         );
    1119         [ #  # ]:          0 :         ws.m_replaced_transactions.push_back(it->GetSharedTx());
    1120                 :            :     }
    1121                 :          0 :     m_pool.RemoveStaged(ws.m_all_conflicting, false, MemPoolRemovalReason::REPLACED);
    1122                 :            : 
    1123                 :            :     // This transaction should only count for fee estimation if:
    1124                 :            :     // - it's not being re-added during a reorg which bypasses typical mempool fee limits
    1125                 :            :     // - the node is not behind
    1126                 :            :     // - the transaction is not dependent on any other transactions in the mempool
    1127                 :            :     // - it's not part of a package. Since package relay is not currently supported, this
    1128                 :            :     // transaction has not necessarily been accepted to miners' mempools.
    1129   [ #  #  #  #  :          0 :     bool validForFeeEstimation = !bypass_limits && !args.m_package_submission && IsCurrentForFeeEstimation(m_active_chainstate) && m_pool.HasNoInputsOf(tx);
                   #  # ]
    1130                 :            : 
    1131                 :            :     // Store transaction in memory
    1132                 :          0 :     m_pool.addUnchecked(*entry, ws.m_ancestors, validForFeeEstimation);
    1133                 :            : 
    1134                 :            :     // trim mempool and check if tx was trimmed
    1135                 :            :     // If we are validating a package, don't trim here because we could evict a previous transaction
    1136                 :            :     // in the package. LimitMempoolSize() should be called at the very end to make sure the mempool
    1137                 :            :     // is still within limits and package submission happens atomically.
    1138   [ #  #  #  # ]:          0 :     if (!args.m_package_submission && !bypass_limits) {
    1139                 :          0 :         LimitMempoolSize(m_pool, m_active_chainstate.CoinsTip());
    1140         [ #  # ]:          0 :         if (!m_pool.exists(GenTxid::Txid(hash)))
    1141   [ #  #  #  #  :          0 :             return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "mempool full");
                   #  # ]
    1142                 :          0 :     }
    1143                 :          0 :     return true;
    1144                 :          0 : }
    1145                 :            : 
    1146                 :          0 : bool MemPoolAccept::SubmitPackage(const ATMPArgs& args, std::vector<Workspace>& workspaces,
    1147                 :            :                                   PackageValidationState& package_state,
    1148                 :            :                                   std::map<uint256, MempoolAcceptResult>& results)
    1149                 :            : {
    1150                 :          0 :     AssertLockHeld(cs_main);
    1151                 :          0 :     AssertLockHeld(m_pool.cs);
    1152                 :            :     // Sanity check: none of the transactions should be in the mempool, and none of the transactions
    1153                 :            :     // should have a same-txid-different-witness equivalent in the mempool.
    1154         [ #  # ]:          0 :     assert(std::all_of(workspaces.cbegin(), workspaces.cend(), [this](const auto& ws){
    1155                 :            :         return !m_pool.exists(GenTxid::Txid(ws.m_ptx->GetHash())); }));
    1156                 :            : 
    1157                 :          0 :     bool all_submitted = true;
    1158                 :            :     // ConsensusScriptChecks adds to the script cache and is therefore consensus-critical;
    1159                 :            :     // CheckInputsFromMempoolAndCache asserts that transactions only spend coins available from the
    1160                 :            :     // mempool or UTXO set. Submit each transaction to the mempool immediately after calling
    1161                 :            :     // ConsensusScriptChecks to make the outputs available for subsequent transactions.
    1162         [ #  # ]:          0 :     for (Workspace& ws : workspaces) {
    1163         [ #  # ]:          0 :         if (!ConsensusScriptChecks(args, ws)) {
    1164   [ #  #  #  # ]:          0 :             results.emplace(ws.m_ptx->GetWitnessHash(), MempoolAcceptResult::Failure(ws.m_state));
    1165                 :            :             // Since PolicyScriptChecks() passed, this should never fail.
    1166                 :          0 :             Assume(false);
    1167                 :          0 :             all_submitted = false;
    1168   [ #  #  #  # ]:          0 :             package_state.Invalid(PackageValidationResult::PCKG_MEMPOOL_ERROR,
    1169         [ #  # ]:          0 :                                   strprintf("BUG! PolicyScriptChecks succeeded but ConsensusScriptChecks failed: %s",
    1170                 :          0 :                                             ws.m_ptx->GetHash().ToString()));
    1171                 :          0 :         }
    1172                 :            : 
    1173                 :            :         // Re-calculate mempool ancestors to call addUnchecked(). They may have changed since the
    1174                 :            :         // last calculation done in PreChecks, since package ancestors have already been submitted.
    1175                 :            :         {
    1176                 :          0 :             auto ancestors{m_pool.CalculateMemPoolAncestors(*ws.m_entry, m_pool.m_limits)};
    1177         [ #  # ]:          0 :             if(!ancestors) {
    1178   [ #  #  #  #  :          0 :                 results.emplace(ws.m_ptx->GetWitnessHash(), MempoolAcceptResult::Failure(ws.m_state));
             #  #  #  # ]
    1179                 :            :                 // Since PreChecks() and PackageMempoolChecks() both enforce limits, this should never fail.
    1180                 :          0 :                 Assume(false);
    1181                 :          0 :                 all_submitted = false;
    1182   [ #  #  #  # ]:          0 :                 package_state.Invalid(PackageValidationResult::PCKG_MEMPOOL_ERROR,
    1183         [ #  # ]:          0 :                                     strprintf("BUG! Mempool ancestors or descendants were underestimated: %s",
    1184         [ #  # ]:          0 :                                                 ws.m_ptx->GetHash().ToString()));
    1185                 :          0 :             }
    1186         [ #  # ]:          0 :             ws.m_ancestors = std::move(ancestors).value_or(ws.m_ancestors);
    1187                 :          0 :         }
    1188                 :            :         // If we call LimitMempoolSize() for each individual Finalize(), the mempool will not take
    1189                 :            :         // the transaction's descendant feerate into account because it hasn't seen them yet. Also,
    1190                 :            :         // we risk evicting a transaction that a subsequent package transaction depends on. Instead,
    1191                 :            :         // allow the mempool to temporarily bypass limits, the maximum package size) while
    1192                 :            :         // submitting transactions individually and then trim at the very end.
    1193         [ #  # ]:          0 :         if (!Finalize(args, ws)) {
    1194   [ #  #  #  # ]:          0 :             results.emplace(ws.m_ptx->GetWitnessHash(), MempoolAcceptResult::Failure(ws.m_state));
    1195                 :            :             // Since LimitMempoolSize() won't be called, this should never fail.
    1196                 :          0 :             Assume(false);
    1197                 :          0 :             all_submitted = false;
    1198   [ #  #  #  # ]:          0 :             package_state.Invalid(PackageValidationResult::PCKG_MEMPOOL_ERROR,
    1199         [ #  # ]:          0 :                                   strprintf("BUG! Adding to mempool failed: %s", ws.m_ptx->GetHash().ToString()));
    1200                 :          0 :         }
    1201                 :            :     }
    1202                 :            : 
    1203                 :          0 :     std::vector<uint256> all_package_wtxids;
    1204         [ #  # ]:          0 :     all_package_wtxids.reserve(workspaces.size());
    1205   [ #  #  #  # ]:          0 :     std::transform(workspaces.cbegin(), workspaces.cend(), std::back_inserter(all_package_wtxids),
    1206                 :          0 :                    [](const auto& ws) { return ws.m_ptx->GetWitnessHash(); });
    1207                 :            : 
    1208                 :            :     // Add successful results. The returned results may change later if LimitMempoolSize() evicts them.
    1209         [ #  # ]:          0 :     for (Workspace& ws : workspaces) {
    1210         [ #  # ]:          0 :         const auto effective_feerate = args.m_package_feerates ? ws.m_package_feerate :
    1211         [ #  # ]:          0 :             CFeeRate{ws.m_modified_fees, static_cast<uint32_t>(ws.m_vsize)};
    1212   [ #  #  #  #  :          0 :         const auto effective_feerate_wtxids = args.m_package_feerates ? all_package_wtxids :
             #  #  #  # ]
    1213   [ #  #  #  # ]:          0 :             std::vector<uint256>({ws.m_ptx->GetWitnessHash()});
    1214   [ #  #  #  # ]:          0 :         results.emplace(ws.m_ptx->GetWitnessHash(),
    1215   [ #  #  #  # ]:          0 :                         MempoolAcceptResult::Success(std::move(ws.m_replaced_transactions), ws.m_vsize,
    1216                 :          0 :                                          ws.m_base_fees, effective_feerate, effective_feerate_wtxids));
    1217   [ #  #  #  # ]:          0 :         GetMainSignals().TransactionAddedToMempool(ws.m_ptx, m_pool.GetAndIncrementSequence());
    1218                 :          0 :     }
    1219                 :          0 :     return all_submitted;
    1220                 :          0 : }
    1221                 :            : 
    1222                 :          0 : MempoolAcceptResult MemPoolAccept::AcceptSingleTransaction(const CTransactionRef& ptx, ATMPArgs& args)
    1223                 :            : {
    1224                 :          0 :     AssertLockHeld(cs_main);
    1225                 :          0 :     LOCK(m_pool.cs); // mempool "read lock" (held through GetMainSignals().TransactionAddedToMempool())
    1226                 :            : 
    1227         [ #  # ]:          0 :     Workspace ws(ptx);
    1228                 :            : 
    1229   [ #  #  #  #  :          0 :     if (!PreChecks(args, ws)) return MempoolAcceptResult::Failure(ws.m_state);
             #  #  #  # ]
    1230                 :            : 
    1231   [ #  #  #  #  :          0 :     if (m_rbf && !ReplacementChecks(ws)) return MempoolAcceptResult::Failure(ws.m_state);
          #  #  #  #  #  
                      # ]
    1232                 :            : 
    1233                 :            :     // Perform the inexpensive checks first and avoid hashing and signature verification unless
    1234                 :            :     // those checks pass, to mitigate CPU exhaustion denial-of-service attacks.
    1235   [ #  #  #  #  :          0 :     if (!PolicyScriptChecks(args, ws)) return MempoolAcceptResult::Failure(ws.m_state);
             #  #  #  # ]
    1236                 :            : 
    1237   [ #  #  #  #  :          0 :     if (!ConsensusScriptChecks(args, ws)) return MempoolAcceptResult::Failure(ws.m_state);
             #  #  #  # ]
    1238                 :            : 
    1239         [ #  # ]:          0 :     const CFeeRate effective_feerate{ws.m_modified_fees, static_cast<uint32_t>(ws.m_vsize)};
    1240   [ #  #  #  # ]:          0 :     const std::vector<uint256> single_wtxid{ws.m_ptx->GetWitnessHash()};
    1241                 :            :     // Tx was accepted, but not added
    1242         [ #  # ]:          0 :     if (args.m_test_accept) {
    1243   [ #  #  #  # ]:          0 :         return MempoolAcceptResult::Success(std::move(ws.m_replaced_transactions), ws.m_vsize,
    1244                 :          0 :                                             ws.m_base_fees, effective_feerate, single_wtxid);
    1245                 :            :     }
    1246                 :            : 
    1247   [ #  #  #  #  :          0 :     if (!Finalize(args, ws)) return MempoolAcceptResult::Failure(ws.m_state);
             #  #  #  # ]
    1248                 :            : 
    1249   [ #  #  #  #  :          0 :     GetMainSignals().TransactionAddedToMempool(ptx, m_pool.GetAndIncrementSequence());
                   #  # ]
    1250                 :            : 
    1251   [ #  #  #  # ]:          0 :     return MempoolAcceptResult::Success(std::move(ws.m_replaced_transactions), ws.m_vsize, ws.m_base_fees,
    1252                 :          0 :                                         effective_feerate, single_wtxid);
    1253                 :          0 : }
    1254                 :            : 
    1255                 :          0 : PackageMempoolAcceptResult MemPoolAccept::AcceptMultipleTransactions(const std::vector<CTransactionRef>& txns, ATMPArgs& args)
    1256                 :            : {
    1257                 :          0 :     AssertLockHeld(cs_main);
    1258                 :            : 
    1259                 :            :     // These context-free package limits can be done before taking the mempool lock.
    1260                 :          0 :     PackageValidationState package_state;
    1261   [ #  #  #  #  :          0 :     if (!CheckPackage(txns, package_state)) return PackageMempoolAcceptResult(package_state, {});
             #  #  #  # ]
    1262                 :            : 
    1263                 :          0 :     std::vector<Workspace> workspaces{};
    1264         [ #  # ]:          0 :     workspaces.reserve(txns.size());
    1265   [ #  #  #  # ]:          0 :     std::transform(txns.cbegin(), txns.cend(), std::back_inserter(workspaces),
    1266                 :          0 :                    [](const auto& tx) { return Workspace(tx); });
    1267                 :          0 :     std::map<uint256, MempoolAcceptResult> results;
    1268                 :            : 
    1269   [ #  #  #  # ]:          0 :     LOCK(m_pool.cs);
    1270                 :            : 
    1271                 :            :     // Do all PreChecks first and fail fast to avoid running expensive script checks when unnecessary.
    1272         [ #  # ]:          0 :     for (Workspace& ws : workspaces) {
    1273   [ #  #  #  # ]:          0 :         if (!PreChecks(args, ws)) {
    1274   [ #  #  #  #  :          0 :             package_state.Invalid(PackageValidationResult::PCKG_TX, "transaction failed");
                   #  # ]
    1275                 :            :             // Exit early to avoid doing pointless work. Update the failed tx result; the rest are unfinished.
    1276   [ #  #  #  #  :          0 :             results.emplace(ws.m_ptx->GetWitnessHash(), MempoolAcceptResult::Failure(ws.m_state));
             #  #  #  # ]
    1277   [ #  #  #  # ]:          0 :             return PackageMempoolAcceptResult(package_state, std::move(results));
    1278                 :            :         }
    1279                 :            :         // Make the coins created by this transaction available for subsequent transactions in the
    1280                 :            :         // package to spend. Since we already checked conflicts in the package and we don't allow
    1281                 :            :         // replacements, we don't need to track the coins spent. Note that this logic will need to be
    1282                 :            :         // updated if package replace-by-fee is allowed in the future.
    1283         [ #  # ]:          0 :         assert(!args.m_allow_replacement);
    1284         [ #  # ]:          0 :         m_viewmempool.PackageAddTransaction(ws.m_ptx);
    1285                 :            :     }
    1286                 :            : 
    1287                 :            :     // Transactions must meet two minimum feerates: the mempool minimum fee and min relay fee.
    1288                 :            :     // For transactions consisting of exactly one child and its parents, it suffices to use the
    1289                 :            :     // package feerate (total modified fees / total virtual size) to check this requirement.
    1290         [ #  # ]:          0 :     const auto m_total_vsize = std::accumulate(workspaces.cbegin(), workspaces.cend(), int64_t{0},
    1291                 :          0 :         [](int64_t sum, auto& ws) { return sum + ws.m_vsize; });
    1292         [ #  # ]:          0 :     const auto m_total_modified_fees = std::accumulate(workspaces.cbegin(), workspaces.cend(), CAmount{0},
    1293                 :          0 :         [](CAmount sum, auto& ws) { return sum + ws.m_modified_fees; });
    1294         [ #  # ]:          0 :     const CFeeRate package_feerate(m_total_modified_fees, m_total_vsize);
    1295                 :          0 :     TxValidationState placeholder_state;
    1296   [ #  #  #  # ]:          0 :     if (args.m_package_feerates &&
    1297         [ #  # ]:          0 :         !CheckFeeRate(m_total_vsize, m_total_modified_fees, placeholder_state)) {
    1298   [ #  #  #  #  :          0 :         package_state.Invalid(PackageValidationResult::PCKG_POLICY, "package-fee-too-low");
                   #  # ]
    1299   [ #  #  #  # ]:          0 :         return PackageMempoolAcceptResult(package_state, {});
    1300                 :            :     }
    1301                 :            : 
    1302                 :            :     // Apply package mempool ancestor/descendant limits. Skip if there is only one transaction,
    1303                 :            :     // because it's unnecessary. Also, CPFP carve out can increase the limit for individual
    1304                 :            :     // transactions, but this exemption is not extended to packages in CheckPackageLimits().
    1305                 :          0 :     std::string err_string;
    1306   [ #  #  #  #  :          0 :     if (txns.size() > 1 && !PackageMempoolChecks(txns, m_total_vsize, package_state)) {
                   #  # ]
    1307   [ #  #  #  # ]:          0 :         return PackageMempoolAcceptResult(package_state, std::move(results));
    1308                 :            :     }
    1309                 :            : 
    1310                 :          0 :     std::vector<uint256> all_package_wtxids;
    1311         [ #  # ]:          0 :     all_package_wtxids.reserve(workspaces.size());
    1312   [ #  #  #  # ]:          0 :     std::transform(workspaces.cbegin(), workspaces.cend(), std::back_inserter(all_package_wtxids),
    1313                 :          0 :                    [](const auto& ws) { return ws.m_ptx->GetWitnessHash(); });
    1314         [ #  # ]:          0 :     for (Workspace& ws : workspaces) {
    1315                 :          0 :         ws.m_package_feerate = package_feerate;
    1316   [ #  #  #  # ]:          0 :         if (!PolicyScriptChecks(args, ws)) {
    1317                 :            :             // Exit early to avoid doing pointless work. Update the failed tx result; the rest are unfinished.
    1318   [ #  #  #  #  :          0 :             package_state.Invalid(PackageValidationResult::PCKG_TX, "transaction failed");
                   #  # ]
    1319   [ #  #  #  #  :          0 :             results.emplace(ws.m_ptx->GetWitnessHash(), MempoolAcceptResult::Failure(ws.m_state));
             #  #  #  # ]
    1320   [ #  #  #  # ]:          0 :             return PackageMempoolAcceptResult(package_state, std::move(results));
    1321                 :            :         }
    1322         [ #  # ]:          0 :         if (args.m_test_accept) {
    1323         [ #  # ]:          0 :             const auto effective_feerate = args.m_package_feerates ? ws.m_package_feerate :
    1324         [ #  # ]:          0 :                 CFeeRate{ws.m_modified_fees, static_cast<uint32_t>(ws.m_vsize)};
    1325   [ #  #  #  #  :          0 :             const auto effective_feerate_wtxids = args.m_package_feerates ? all_package_wtxids :
             #  #  #  # ]
    1326   [ #  #  #  # ]:          0 :                 std::vector<uint256>{ws.m_ptx->GetWitnessHash()};
    1327   [ #  #  #  # ]:          0 :             results.emplace(ws.m_ptx->GetWitnessHash(),
    1328   [ #  #  #  # ]:          0 :                             MempoolAcceptResult::Success(std::move(ws.m_replaced_transactions),
    1329                 :          0 :                                                          ws.m_vsize, ws.m_base_fees, effective_feerate,
    1330                 :            :                                                          effective_feerate_wtxids));
    1331                 :          0 :         }
    1332                 :            :     }
    1333                 :            : 
    1334   [ #  #  #  #  :          0 :     if (args.m_test_accept) return PackageMempoolAcceptResult(package_state, std::move(results));
                   #  # ]
    1335                 :            : 
    1336   [ #  #  #  # ]:          0 :     if (!SubmitPackage(args, workspaces, package_state, results)) {
    1337                 :            :         // PackageValidationState filled in by SubmitPackage().
    1338   [ #  #  #  # ]:          0 :         return PackageMempoolAcceptResult(package_state, std::move(results));
    1339                 :            :     }
    1340                 :            : 
    1341   [ #  #  #  # ]:          0 :     return PackageMempoolAcceptResult(package_state, std::move(results));
    1342                 :          0 : }
    1343                 :            : 
    1344                 :          0 : PackageMempoolAcceptResult MemPoolAccept::AcceptSubPackage(const std::vector<CTransactionRef>& subpackage, ATMPArgs& args)
    1345                 :            : {
    1346                 :          0 :     AssertLockHeld(::cs_main);
    1347                 :          0 :     AssertLockHeld(m_pool.cs);
    1348                 :          0 :     auto result = [&]() EXCLUSIVE_LOCKS_REQUIRED(::cs_main, m_pool.cs) {
    1349         [ #  # ]:          0 :         if (subpackage.size() > 1) {
    1350                 :          0 :             return AcceptMultipleTransactions(subpackage, args);
    1351                 :            :         }
    1352                 :          0 :         const auto& tx = subpackage.front();
    1353                 :          0 :         ATMPArgs single_args = ATMPArgs::SingleInPackageAccept(args);
    1354                 :          0 :         const auto single_res = AcceptSingleTransaction(tx, single_args);
    1355                 :          0 :         PackageValidationState package_state_wrapped;
    1356         [ #  # ]:          0 :         if (single_res.m_result_type != MempoolAcceptResult::ResultType::VALID) {
    1357   [ #  #  #  #  :          0 :             package_state_wrapped.Invalid(PackageValidationResult::PCKG_TX, "transaction failed");
                   #  # ]
    1358                 :          0 :         }
    1359   [ #  #  #  #  :          0 :         return PackageMempoolAcceptResult(package_state_wrapped, {{tx->GetWitnessHash(), single_res}});
          #  #  #  #  #  
                      # ]
    1360                 :          0 :     }();
    1361                 :            :     // Clean up m_view and m_viewmempool so that other subpackage evaluations don't have access to
    1362                 :            :     // coins they shouldn't. Keep some coins in order to minimize re-fetching coins from the UTXO set.
    1363                 :            :     //
    1364                 :            :     // There are 3 kinds of coins in m_view:
    1365                 :            :     // (1) Temporary coins from the transactions in subpackage, constructed by m_viewmempool.
    1366                 :            :     // (2) Mempool coins from transactions in the mempool, constructed by m_viewmempool.
    1367                 :            :     // (3) Confirmed coins fetched from our current UTXO set.
    1368                 :            :     //
    1369                 :            :     // (1) Temporary coins need to be removed, regardless of whether the transaction was submitted.
    1370                 :            :     // If the transaction was submitted to the mempool, m_viewmempool will be able to fetch them from
    1371                 :            :     // there. If it wasn't submitted to mempool, it is incorrect to keep them - future calls may try
    1372                 :            :     // to spend those coins that don't actually exist.
    1373                 :            :     // (2) Mempool coins also need to be removed. If the mempool contents have changed as a result
    1374                 :            :     // of submitting or replacing transactions, coins previously fetched from mempool may now be
    1375                 :            :     // spent or nonexistent. Those coins need to be deleted from m_view.
    1376                 :            :     // (3) Confirmed coins don't need to be removed. The chainstate has not changed (we are
    1377                 :            :     // holding cs_main and no blocks have been processed) so the confirmed tx cannot disappear like
    1378                 :            :     // a mempool tx can. The coin may now be spent after we submitted a tx to mempool, but
    1379                 :            :     // we have already checked that the package does not have 2 transactions spending the same coin.
    1380                 :            :     // Keeping them in m_view is an optimization to not re-fetch confirmed coins if we later look up
    1381                 :            :     // inputs for this transaction again.
    1382   [ #  #  #  # ]:          0 :     for (const auto& outpoint : m_viewmempool.GetNonBaseCoins()) {
    1383                 :            :         // In addition to resetting m_viewmempool, we also need to manually delete these coins from
    1384                 :            :         // m_view because it caches copies of the coins it fetched from m_viewmempool previously.
    1385         [ #  # ]:          0 :         m_view.Uncache(outpoint);
    1386                 :            :     }
    1387                 :            :     // This deletes the temporary and mempool coins.
    1388         [ #  # ]:          0 :     m_viewmempool.Reset();
    1389                 :          0 :     return result;
    1390         [ #  # ]:          0 : }
    1391                 :            : 
    1392                 :          0 : PackageMempoolAcceptResult MemPoolAccept::AcceptPackage(const Package& package, ATMPArgs& args)
    1393                 :            : {
    1394                 :          0 :     AssertLockHeld(cs_main);
    1395                 :            :     // Used if returning a PackageMempoolAcceptResult directly from this function.
    1396                 :          0 :     PackageValidationState package_state_quit_early;
    1397                 :            : 
    1398                 :            :     // Check that the package is well-formed. If it isn't, we won't try to validate any of the
    1399                 :            :     // transactions and thus won't return any MempoolAcceptResults, just a package-wide error.
    1400                 :            : 
    1401                 :            :     // Context-free package checks.
    1402   [ #  #  #  #  :          0 :     if (!CheckPackage(package, package_state_quit_early)) return PackageMempoolAcceptResult(package_state_quit_early, {});
             #  #  #  # ]
    1403                 :            : 
    1404                 :            :     // All transactions in the package must be a parent of the last transaction. This is just an
    1405                 :            :     // opportunity for us to fail fast on a context-free check without taking the mempool lock.
    1406   [ #  #  #  # ]:          0 :     if (!IsChildWithParents(package)) {
    1407   [ #  #  #  #  :          0 :         package_state_quit_early.Invalid(PackageValidationResult::PCKG_POLICY, "package-not-child-with-parents");
                   #  # ]
    1408   [ #  #  #  # ]:          0 :         return PackageMempoolAcceptResult(package_state_quit_early, {});
    1409                 :            :     }
    1410                 :            : 
    1411                 :            :     // IsChildWithParents() guarantees the package is > 1 transactions.
    1412         [ #  # ]:          0 :     assert(package.size() > 1);
    1413                 :            :     // The package must be 1 child with all of its unconfirmed parents. The package is expected to
    1414                 :            :     // be sorted, so the last transaction is the child.
    1415                 :          0 :     const auto& child = package.back();
    1416         [ #  # ]:          0 :     std::unordered_set<uint256, SaltedTxidHasher> unconfirmed_parent_txids;
    1417         [ #  # ]:          0 :     std::transform(package.cbegin(), package.cend() - 1,
    1418         [ #  # ]:          0 :                    std::inserter(unconfirmed_parent_txids, unconfirmed_parent_txids.end()),
    1419                 :          0 :                    [](const auto& tx) { return tx->GetHash(); });
    1420                 :            : 
    1421                 :            :     // All child inputs must refer to a preceding package transaction or a confirmed UTXO. The only
    1422                 :            :     // way to verify this is to look up the child's inputs in our current coins view (not including
    1423                 :            :     // mempool), and enforce that all parents not present in the package be available at chain tip.
    1424                 :            :     // Since this check can bring new coins into the coins cache, keep track of these coins and
    1425                 :            :     // uncache them if we don't end up submitting this package to the mempool.
    1426         [ #  # ]:          0 :     const CCoinsViewCache& coins_tip_cache = m_active_chainstate.CoinsTip();
    1427         [ #  # ]:          0 :     for (const auto& input : child->vin) {
    1428   [ #  #  #  # ]:          0 :         if (!coins_tip_cache.HaveCoinInCache(input.prevout)) {
    1429         [ #  # ]:          0 :             args.m_coins_to_uncache.push_back(input.prevout);
    1430                 :          0 :         }
    1431                 :            :     }
    1432                 :            :     // Using the MemPoolAccept m_view cache allows us to look up these same coins faster later.
    1433                 :            :     // This should be connecting directly to CoinsTip, not to m_viewmempool, because we specifically
    1434                 :            :     // require inputs to be confirmed if they aren't in the package.
    1435   [ #  #  #  # ]:          0 :     m_view.SetBackend(m_active_chainstate.CoinsTip());
    1436                 :          0 :     const auto package_or_confirmed = [this, &unconfirmed_parent_txids](const auto& input) {
    1437         [ #  # ]:          0 :          return unconfirmed_parent_txids.count(input.prevout.hash) > 0 || m_view.HaveCoin(input.prevout);
    1438                 :            :     };
    1439   [ #  #  #  # ]:          0 :     if (!std::all_of(child->vin.cbegin(), child->vin.cend(), package_or_confirmed)) {
    1440   [ #  #  #  #  :          0 :         package_state_quit_early.Invalid(PackageValidationResult::PCKG_POLICY, "package-not-child-with-unconfirmed-parents");
                   #  # ]
    1441   [ #  #  #  # ]:          0 :         return PackageMempoolAcceptResult(package_state_quit_early, {});
    1442                 :            :     }
    1443                 :            :     // Protect against bugs where we pull more inputs from disk that miss being added to
    1444                 :            :     // coins_to_uncache. The backend will be connected again when needed in PreChecks.
    1445         [ #  # ]:          0 :     m_view.SetBackend(m_dummy);
    1446                 :            : 
    1447   [ #  #  #  # ]:          0 :     LOCK(m_pool.cs);
    1448                 :            :     // Stores results from which we will create the returned PackageMempoolAcceptResult.
    1449                 :            :     // A result may be changed if a mempool transaction is evicted later due to LimitMempoolSize().
    1450                 :          0 :     std::map<uint256, MempoolAcceptResult> results_final;
    1451                 :            :     // Results from individual validation which will be returned if no other result is available for
    1452                 :            :     // this transaction. "Nonfinal" because if a transaction fails by itself but succeeds later
    1453                 :            :     // (i.e. when evaluated with a fee-bumping child), the result in this map may be discarded.
    1454                 :          0 :     std::map<uint256, MempoolAcceptResult> individual_results_nonfinal;
    1455                 :          0 :     bool quit_early{false};
    1456                 :          0 :     std::vector<CTransactionRef> txns_package_eval;
    1457         [ #  # ]:          0 :     for (const auto& tx : package) {
    1458         [ #  # ]:          0 :         const auto& wtxid = tx->GetWitnessHash();
    1459                 :          0 :         const auto& txid = tx->GetHash();
    1460                 :            :         // There are 3 possibilities: already in mempool, same-txid-diff-wtxid already in mempool,
    1461                 :            :         // or not in mempool. An already confirmed tx is treated as one not in mempool, because all
    1462                 :            :         // we know is that the inputs aren't available.
    1463   [ #  #  #  #  :          0 :         if (m_pool.exists(GenTxid::Wtxid(wtxid))) {
                   #  # ]
    1464                 :            :             // Exact transaction already exists in the mempool.
    1465                 :            :             // Node operators are free to set their mempool policies however they please, nodes may receive
    1466                 :            :             // transactions in different orders, and malicious counterparties may try to take advantage of
    1467                 :            :             // policy differences to pin or delay propagation of transactions. As such, it's possible for
    1468                 :            :             // some package transaction(s) to already be in the mempool, and we don't want to reject the
    1469                 :            :             // entire package in that case (as that could be a censorship vector). De-duplicate the
    1470                 :            :             // transactions that are already in the mempool, and only call AcceptMultipleTransactions() with
    1471                 :            :             // the new transactions. This ensures we don't double-count transaction counts and sizes when
    1472                 :            :             // checking ancestor/descendant limits, or double-count transaction fees for fee-related policy.
    1473         [ #  # ]:          0 :             auto iter = m_pool.GetIter(txid);
    1474         [ #  # ]:          0 :             assert(iter != std::nullopt);
    1475   [ #  #  #  #  :          0 :             results_final.emplace(wtxid, MempoolAcceptResult::MempoolTx(iter.value()->GetTxSize(), iter.value()->GetFee()));
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    1476   [ #  #  #  #  :          0 :         } else if (m_pool.exists(GenTxid::Txid(txid))) {
                   #  # ]
    1477                 :            :             // Transaction with the same non-witness data but different witness (same txid,
    1478                 :            :             // different wtxid) already exists in the mempool.
    1479                 :            :             //
    1480                 :            :             // We don't allow replacement transactions right now, so just swap the package
    1481                 :            :             // transaction for the mempool one. Note that we are ignoring the validity of the
    1482                 :            :             // package transaction passed in.
    1483                 :            :             // TODO: allow witness replacement in packages.
    1484         [ #  # ]:          0 :             auto iter = m_pool.GetIter(txid);
    1485         [ #  # ]:          0 :             assert(iter != std::nullopt);
    1486                 :            :             // Provide the wtxid of the mempool tx so that the caller can look it up in the mempool.
    1487   [ #  #  #  #  :          0 :             results_final.emplace(wtxid, MempoolAcceptResult::MempoolTxDifferentWitness(iter.value()->GetTx().GetWitnessHash()));
          #  #  #  #  #  
                      # ]
    1488                 :          0 :         } else {
    1489                 :            :             // Transaction does not already exist in the mempool.
    1490                 :            :             // Try submitting the transaction on its own.
    1491   [ #  #  #  # ]:          0 :             const auto single_package_res = AcceptSubPackage({tx}, args);
    1492         [ #  # ]:          0 :             const auto& single_res = single_package_res.m_tx_results.at(wtxid);
    1493         [ #  # ]:          0 :             if (single_res.m_result_type == MempoolAcceptResult::ResultType::VALID) {
    1494                 :            :                 // The transaction succeeded on its own and is now in the mempool. Don't include it
    1495                 :            :                 // in package validation, because its fees should only be "used" once.
    1496   [ #  #  #  #  :          0 :                 assert(m_pool.exists(GenTxid::Wtxid(wtxid)));
                   #  # ]
    1497         [ #  # ]:          0 :                 results_final.emplace(wtxid, single_res);
    1498   [ #  #  #  #  :          0 :             } else if (single_res.m_state.GetResult() != TxValidationResult::TX_MEMPOOL_POLICY &&
                   #  # ]
    1499         [ #  # ]:          0 :                        single_res.m_state.GetResult() != TxValidationResult::TX_MISSING_INPUTS) {
    1500                 :            :                 // Package validation policy only differs from individual policy in its evaluation
    1501                 :            :                 // of feerate. For example, if a transaction fails here due to violation of a
    1502                 :            :                 // consensus rule, the result will not change when it is submitted as part of a
    1503                 :            :                 // package. To minimize the amount of repeated work, unless the transaction fails
    1504                 :            :                 // due to feerate or missing inputs (its parent is a previous transaction in the
    1505                 :            :                 // package that failed due to feerate), don't run package validation. Note that this
    1506                 :            :                 // decision might not make sense if different types of packages are allowed in the
    1507                 :            :                 // future.  Continue individually validating the rest of the transactions, because
    1508                 :            :                 // some of them may still be valid.
    1509                 :          0 :                 quit_early = true;
    1510   [ #  #  #  #  :          0 :                 package_state_quit_early.Invalid(PackageValidationResult::PCKG_TX, "transaction failed");
                   #  # ]
    1511         [ #  # ]:          0 :                 individual_results_nonfinal.emplace(wtxid, single_res);
    1512                 :          0 :             } else {
    1513         [ #  # ]:          0 :                 individual_results_nonfinal.emplace(wtxid, single_res);
    1514         [ #  # ]:          0 :                 txns_package_eval.push_back(tx);
    1515                 :            :             }
    1516                 :          0 :         }
    1517                 :            :     }
    1518                 :            : 
    1519   [ #  #  #  #  :          0 :     auto multi_submission_result = quit_early || txns_package_eval.empty() ? PackageMempoolAcceptResult(package_state_quit_early, {}) :
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    1520         [ #  # ]:          0 :         AcceptSubPackage(txns_package_eval, args);
    1521                 :          0 :     PackageValidationState& package_state_final = multi_submission_result.m_state;
    1522                 :            : 
    1523                 :            :     // Make sure we haven't exceeded max mempool size.
    1524                 :            :     // Package transactions that were submitted to mempool or already in mempool may be evicted.
    1525   [ #  #  #  # ]:          0 :     LimitMempoolSize(m_pool, m_active_chainstate.CoinsTip());
    1526                 :            : 
    1527         [ #  # ]:          0 :     for (const auto& tx : package) {
    1528         [ #  # ]:          0 :         const auto& wtxid = tx->GetWitnessHash();
    1529   [ #  #  #  # ]:          0 :         if (multi_submission_result.m_tx_results.count(wtxid) > 0) {
    1530                 :            :             // We shouldn't have re-submitted if the tx result was already in results_final.
    1531         [ #  # ]:          0 :             Assume(results_final.count(wtxid) == 0);
    1532                 :            :             // If it was submitted, check to see if the tx is still in the mempool. It could have
    1533                 :            :             // been evicted due to LimitMempoolSize() above.
    1534         [ #  # ]:          0 :             const auto& txresult = multi_submission_result.m_tx_results.at(wtxid);
    1535   [ #  #  #  #  :          0 :             if (txresult.m_result_type == MempoolAcceptResult::ResultType::VALID && !m_pool.exists(GenTxid::Wtxid(wtxid))) {
             #  #  #  # ]
    1536   [ #  #  #  #  :          0 :                 package_state_final.Invalid(PackageValidationResult::PCKG_TX, "transaction failed");
                   #  # ]
    1537                 :          0 :                 TxValidationState mempool_full_state;
    1538   [ #  #  #  #  :          0 :                 mempool_full_state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "mempool full");
                   #  # ]
    1539   [ #  #  #  #  :          0 :                 results_final.emplace(wtxid, MempoolAcceptResult::Failure(mempool_full_state));
                   #  # ]
    1540                 :          0 :             } else {
    1541         [ #  # ]:          0 :                 results_final.emplace(wtxid, txresult);
    1542                 :            :             }
    1543   [ #  #  #  # ]:          0 :         } else if (const auto it{results_final.find(wtxid)}; it != results_final.end()) {
    1544                 :            :             // Already-in-mempool transaction. Check to see if it's still there, as it could have
    1545                 :            :             // been evicted when LimitMempoolSize() was called.
    1546                 :          0 :             Assume(it->second.m_result_type != MempoolAcceptResult::ResultType::INVALID);
    1547         [ #  # ]:          0 :             Assume(individual_results_nonfinal.count(wtxid) == 0);
    1548                 :            :             // Query by txid to include the same-txid-different-witness ones.
    1549   [ #  #  #  #  :          0 :             if (!m_pool.exists(GenTxid::Txid(tx->GetHash()))) {
                   #  # ]
    1550   [ #  #  #  #  :          0 :                 package_state_final.Invalid(PackageValidationResult::PCKG_TX, "transaction failed");
                   #  # ]
    1551                 :          0 :                 TxValidationState mempool_full_state;
    1552   [ #  #  #  #  :          0 :                 mempool_full_state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "mempool full");
                   #  # ]
    1553                 :            :                 // Replace the previous result.
    1554         [ #  # ]:          0 :                 results_final.erase(wtxid);
    1555   [ #  #  #  #  :          0 :                 results_final.emplace(wtxid, MempoolAcceptResult::Failure(mempool_full_state));
                   #  # ]
    1556                 :          0 :             }
    1557   [ #  #  #  # ]:          0 :         } else if (const auto it{individual_results_nonfinal.find(wtxid)}; it != individual_results_nonfinal.end()) {
    1558                 :          0 :             Assume(it->second.m_result_type == MempoolAcceptResult::ResultType::INVALID);
    1559                 :            :             // Interesting result from previous processing.
    1560         [ #  # ]:          0 :             results_final.emplace(wtxid, it->second);
    1561                 :          0 :         }
    1562                 :            :     }
    1563                 :          0 :     Assume(results_final.size() == package.size());
    1564   [ #  #  #  # ]:          0 :     return PackageMempoolAcceptResult(package_state_final, std::move(results_final));
    1565                 :          0 : }
    1566                 :            : 
    1567                 :            : } // anon namespace
    1568                 :            : 
    1569                 :          0 : MempoolAcceptResult AcceptToMemoryPool(Chainstate& active_chainstate, const CTransactionRef& tx,
    1570                 :            :                                        int64_t accept_time, bool bypass_limits, bool test_accept)
    1571                 :            :     EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
    1572                 :            : {
    1573                 :          0 :     AssertLockHeld(::cs_main);
    1574                 :          0 :     const CChainParams& chainparams{active_chainstate.m_chainman.GetParams()};
    1575         [ #  # ]:          0 :     assert(active_chainstate.GetMempool() != nullptr);
    1576                 :          0 :     CTxMemPool& pool{*active_chainstate.GetMempool()};
    1577                 :            : 
    1578                 :          0 :     std::vector<COutPoint> coins_to_uncache;
    1579         [ #  # ]:          0 :     auto args = MemPoolAccept::ATMPArgs::SingleAccept(chainparams, accept_time, bypass_limits, coins_to_uncache, test_accept);
    1580   [ #  #  #  # ]:          0 :     MempoolAcceptResult result = MemPoolAccept(pool, active_chainstate).AcceptSingleTransaction(tx, args);
    1581         [ #  # ]:          0 :     if (result.m_result_type != MempoolAcceptResult::ResultType::VALID) {
    1582                 :            :         // Remove coins that were not present in the coins cache before calling
    1583                 :            :         // AcceptSingleTransaction(); this is to prevent memory DoS in case we receive a large
    1584                 :            :         // number of invalid transactions that attempt to overrun the in-memory coins cache
    1585                 :            :         // (`CCoinsViewCache::cacheCoins`).
    1586                 :            : 
    1587         [ #  # ]:          0 :         for (const COutPoint& hashTx : coins_to_uncache)
    1588   [ #  #  #  # ]:          0 :             active_chainstate.CoinsTip().Uncache(hashTx);
    1589                 :            :         TRACE2(mempool, rejected,
    1590                 :            :                 tx->GetHash().data(),
    1591                 :            :                 result.m_state.GetRejectReason().c_str()
    1592                 :            :         );
    1593                 :          0 :     }
    1594                 :            :     // After we've (potentially) uncached entries, ensure our coins cache is still within its size limits
    1595                 :          0 :     BlockValidationState state_dummy;
    1596         [ #  # ]:          0 :     active_chainstate.FlushStateToDisk(state_dummy, FlushStateMode::PERIODIC);
    1597                 :          0 :     return result;
    1598         [ #  # ]:          0 : }
    1599                 :            : 
    1600                 :          0 : PackageMempoolAcceptResult ProcessNewPackage(Chainstate& active_chainstate, CTxMemPool& pool,
    1601                 :            :                                                    const Package& package, bool test_accept)
    1602                 :            : {
    1603                 :          0 :     AssertLockHeld(cs_main);
    1604         [ #  # ]:          0 :     assert(!package.empty());
    1605         [ #  # ]:          0 :     assert(std::all_of(package.cbegin(), package.cend(), [](const auto& tx){return tx != nullptr;}));
    1606                 :            : 
    1607                 :          0 :     std::vector<COutPoint> coins_to_uncache;
    1608         [ #  # ]:          0 :     const CChainParams& chainparams = active_chainstate.m_chainman.GetParams();
    1609         [ #  # ]:          0 :     auto result = [&]() EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
    1610                 :          0 :         AssertLockHeld(cs_main);
    1611         [ #  # ]:          0 :         if (test_accept) {
    1612                 :          0 :             auto args = MemPoolAccept::ATMPArgs::PackageTestAccept(chainparams, GetTime(), coins_to_uncache);
    1613         [ #  # ]:          0 :             return MemPoolAccept(pool, active_chainstate).AcceptMultipleTransactions(package, args);
    1614                 :            :         } else {
    1615                 :          0 :             auto args = MemPoolAccept::ATMPArgs::PackageChildWithParents(chainparams, GetTime(), coins_to_uncache);
    1616         [ #  # ]:          0 :             return MemPoolAccept(pool, active_chainstate).AcceptPackage(package, args);
    1617                 :            :         }
    1618                 :          0 :     }();
    1619                 :            : 
    1620                 :            :     // Uncache coins pertaining to transactions that were not submitted to the mempool.
    1621   [ #  #  #  #  :          0 :     if (test_accept || result.m_state.IsInvalid()) {
                   #  # ]
    1622         [ #  # ]:          0 :         for (const COutPoint& hashTx : coins_to_uncache) {
    1623   [ #  #  #  # ]:          0 :             active_chainstate.CoinsTip().Uncache(hashTx);
    1624                 :            :         }
    1625                 :          0 :     }
    1626                 :            :     // Ensure the coins cache is still within limits.
    1627                 :          0 :     BlockValidationState state_dummy;
    1628         [ #  # ]:          0 :     active_chainstate.FlushStateToDisk(state_dummy, FlushStateMode::PERIODIC);
    1629                 :          0 :     return result;
    1630         [ #  # ]:          0 : }
    1631                 :            : 
    1632                 :          0 : CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusParams)
    1633                 :            : {
    1634                 :          0 :     int halvings = nHeight / consensusParams.nSubsidyHalvingInterval;
    1635                 :            :     // Force block reward to zero when right shift is undefined.
    1636         [ #  # ]:          0 :     if (halvings >= 64)
    1637                 :          0 :         return 0;
    1638                 :            : 
    1639                 :          0 :     CAmount nSubsidy = 50 * COIN;
    1640                 :            :     // Subsidy is cut in half every 210,000 blocks which will occur approximately every 4 years.
    1641                 :          0 :     nSubsidy >>= halvings;
    1642                 :          0 :     return nSubsidy;
    1643                 :          0 : }
    1644                 :            : 
    1645                 :          2 : CoinsViews::CoinsViews(DBParams db_params, CoinsViewOptions options)
    1646         [ +  - ]:          1 :     : m_dbview{std::move(db_params), std::move(options)},
    1647         [ -  + ]:          1 :       m_catcherview(&m_dbview) {}
    1648                 :            : 
    1649                 :          1 : void CoinsViews::InitCache()
    1650                 :            : {
    1651                 :          1 :     AssertLockHeld(::cs_main);
    1652                 :          1 :     m_cacheview = std::make_unique<CCoinsViewCache>(&m_catcherview);
    1653                 :          1 : }
    1654                 :            : 
    1655                 :          4 : Chainstate::Chainstate(
    1656                 :            :     CTxMemPool* mempool,
    1657                 :            :     BlockManager& blockman,
    1658                 :            :     ChainstateManager& chainman,
    1659                 :            :     std::optional<uint256> from_snapshot_blockhash)
    1660                 :          1 :     : m_mempool(mempool),
    1661                 :          1 :       m_blockman(blockman),
    1662                 :          1 :       m_chainman(chainman),
    1663                 :          2 :       m_from_snapshot_blockhash(from_snapshot_blockhash) {}
    1664                 :            : 
    1665                 :          0 : const CBlockIndex* Chainstate::SnapshotBase()
    1666                 :            : {
    1667         [ #  # ]:          0 :     if (!m_from_snapshot_blockhash) return nullptr;
    1668         [ #  # ]:          0 :     if (!m_cached_snapshot_base) m_cached_snapshot_base = Assert(m_chainman.m_blockman.LookupBlockIndex(*m_from_snapshot_blockhash));
    1669                 :          0 :     return m_cached_snapshot_base;
    1670                 :          0 : }
    1671                 :            : 
    1672                 :          1 : void Chainstate::InitCoinsDB(
    1673                 :            :     size_t cache_size_bytes,
    1674                 :            :     bool in_memory,
    1675                 :            :     bool should_wipe,
    1676                 :            :     fs::path leveldb_name)
    1677                 :            : {
    1678         [ +  - ]:          1 :     if (m_from_snapshot_blockhash) {
    1679                 :          0 :         leveldb_name += node::SNAPSHOT_CHAINSTATE_SUFFIX;
    1680                 :          0 :     }
    1681                 :            : 
    1682         [ +  - ]:          1 :     m_coins_views = std::make_unique<CoinsViews>(
    1683                 :          5 :         DBParams{
    1684   [ +  -  +  - ]:          1 :             .path = m_chainman.m_options.datadir / leveldb_name,
    1685                 :          1 :             .cache_bytes = cache_size_bytes,
    1686                 :          1 :             .memory_only = in_memory,
    1687                 :          1 :             .wipe_data = should_wipe,
    1688                 :            :             .obfuscate = true,
    1689                 :          1 :             .options = m_chainman.m_options.coins_db},
    1690                 :          1 :         m_chainman.m_options.coins_view);
    1691                 :          1 : }
    1692                 :            : 
    1693                 :          1 : void Chainstate::InitCoinsCache(size_t cache_size_bytes)
    1694                 :            : {
    1695                 :          1 :     AssertLockHeld(::cs_main);
    1696         [ +  - ]:          1 :     assert(m_coins_views != nullptr);
    1697                 :          1 :     m_coinstip_cache_size_bytes = cache_size_bytes;
    1698                 :          1 :     m_coins_views->InitCache();
    1699                 :          1 : }
    1700                 :            : 
    1701                 :            : // Note that though this is marked const, we may end up modifying `m_cached_finished_ibd`, which
    1702                 :            : // is a performance-related implementation detail. This function must be marked
    1703                 :            : // `const` so that `CValidationInterface` clients (which are given a `const Chainstate*`)
    1704                 :            : // can call it.
    1705                 :            : //
    1706                 :          4 : bool ChainstateManager::IsInitialBlockDownload() const
    1707                 :            : {
    1708                 :            :     // Optimization: pre-test latch before taking the lock.
    1709         [ -  + ]:          4 :     if (m_cached_finished_ibd.load(std::memory_order_relaxed))
    1710                 :          0 :         return false;
    1711                 :            : 
    1712                 :          4 :     LOCK(cs_main);
    1713         [ -  + ]:          4 :     if (m_cached_finished_ibd.load(std::memory_order_relaxed))
    1714                 :          0 :         return false;
    1715   [ +  -  +  - ]:          4 :     if (m_blockman.LoadingBlocks()) {
    1716                 :          0 :         return true;
    1717                 :            :     }
    1718         [ +  - ]:          4 :     CChain& chain{ActiveChain()};
    1719   [ +  -  +  + ]:          4 :     if (chain.Tip() == nullptr) {
    1720                 :          1 :         return true;
    1721                 :            :     }
    1722   [ +  -  +  -  :          3 :     if (chain.Tip()->nChainWork < MinimumChainWork()) {
             +  -  +  - ]
    1723                 :          0 :         return true;
    1724                 :            :     }
    1725   [ +  -  +  -  :          3 :     if (chain.Tip()->Time() < Now<NodeSeconds>() - m_options.max_tip_age) {
          +  -  +  -  +  
                -  +  - ]
    1726                 :          3 :         return true;
    1727                 :            :     }
    1728   [ #  #  #  #  :          0 :     LogPrintf("Leaving InitialBlockDownload (latching to false)\n");
                   #  # ]
    1729                 :          0 :     m_cached_finished_ibd.store(true, std::memory_order_relaxed);
    1730                 :          0 :     return false;
    1731                 :          4 : }
    1732                 :            : 
    1733                 :          1 : void Chainstate::CheckForkWarningConditions()
    1734                 :            : {
    1735                 :          1 :     AssertLockHeld(cs_main);
    1736                 :            : 
    1737                 :            :     // Before we get past initial download, we cannot reliably alert about forks
    1738                 :            :     // (we assume we don't get stuck on a fork before finishing our initial sync)
    1739         [ +  - ]:          1 :     if (m_chainman.IsInitialBlockDownload()) {
    1740                 :          1 :         return;
    1741                 :            :     }
    1742                 :            : 
    1743   [ #  #  #  # ]:          0 :     if (m_chainman.m_best_invalid && m_chainman.m_best_invalid->nChainWork > m_chain.Tip()->nChainWork + (GetBlockProof(*m_chain.Tip()) * 6)) {
    1744   [ #  #  #  #  :          0 :         LogPrintf("%s: Warning: Found invalid chain at least ~6 blocks longer than our best chain.\nChain state database corruption likely.\n", __func__);
                   #  # ]
    1745                 :          0 :         SetfLargeWorkInvalidChainFound(true);
    1746                 :          0 :     } else {
    1747                 :          0 :         SetfLargeWorkInvalidChainFound(false);
    1748                 :            :     }
    1749                 :          1 : }
    1750                 :            : 
    1751                 :            : // Called both upon regular invalid block discovery *and* InvalidateBlock
    1752                 :          0 : void Chainstate::InvalidChainFound(CBlockIndex* pindexNew)
    1753                 :            : {
    1754                 :          0 :     AssertLockHeld(cs_main);
    1755   [ #  #  #  # ]:          0 :     if (!m_chainman.m_best_invalid || pindexNew->nChainWork > m_chainman.m_best_invalid->nChainWork) {
    1756                 :          0 :         m_chainman.m_best_invalid = pindexNew;
    1757                 :          0 :     }
    1758   [ #  #  #  # ]:          0 :     if (m_chainman.m_best_header != nullptr && m_chainman.m_best_header->GetAncestor(pindexNew->nHeight) == pindexNew) {
    1759                 :          0 :         m_chainman.m_best_header = m_chain.Tip();
    1760                 :          0 :     }
    1761                 :            : 
    1762   [ #  #  #  #  :          0 :     LogPrintf("%s: invalid block=%s  height=%d  log2_work=%f  date=%s\n", __func__,
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    1763                 :            :       pindexNew->GetBlockHash().ToString(), pindexNew->nHeight,
    1764                 :            :       log(pindexNew->nChainWork.getdouble())/log(2.0), FormatISO8601DateTime(pindexNew->GetBlockTime()));
    1765                 :          0 :     CBlockIndex *tip = m_chain.Tip();
    1766         [ #  # ]:          0 :     assert (tip);
    1767   [ #  #  #  #  :          0 :     LogPrintf("%s:  current best=%s  height=%d  log2_work=%f  date=%s\n", __func__,
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
    1768                 :            :       tip->GetBlockHash().ToString(), m_chain.Height(), log(tip->nChainWork.getdouble())/log(2.0),
    1769                 :            :       FormatISO8601DateTime(tip->GetBlockTime()));
    1770                 :          0 :     CheckForkWarningConditions();
    1771                 :          0 : }
    1772                 :            : 
    1773                 :            : // Same as InvalidChainFound, above, except not called directly from InvalidateBlock,
    1774                 :            : // which does its own setBlockIndexCandidates management.
    1775                 :          0 : void Chainstate::InvalidBlockFound(CBlockIndex* pindex, const BlockValidationState& state)
    1776                 :            : {
    1777                 :          0 :     AssertLockHeld(cs_main);
    1778         [ #  # ]:          0 :     if (state.GetResult() != BlockValidationResult::BLOCK_MUTATED) {
    1779                 :          0 :         pindex->nStatus |= BLOCK_FAILED_VALID;
    1780                 :          0 :         m_chainman.m_failed_blocks.insert(pindex);
    1781                 :          0 :         m_blockman.m_dirty_blockindex.insert(pindex);
    1782                 :          0 :         setBlockIndexCandidates.erase(pindex);
    1783                 :          0 :         InvalidChainFound(pindex);
    1784                 :          0 :     }
    1785                 :          0 : }
    1786                 :            : 
    1787                 :          0 : void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, CTxUndo &txundo, int nHeight)
    1788                 :            : {
    1789                 :            :     // mark inputs spent
    1790         [ #  # ]:          0 :     if (!tx.IsCoinBase()) {
    1791                 :          0 :         txundo.vprevout.reserve(tx.vin.size());
    1792         [ #  # ]:          0 :         for (const CTxIn &txin : tx.vin) {
    1793                 :          0 :             txundo.vprevout.emplace_back();
    1794                 :          0 :             bool is_spent = inputs.SpendCoin(txin.prevout, &txundo.vprevout.back());
    1795         [ #  # ]:          0 :             assert(is_spent);
    1796                 :            :         }
    1797                 :          0 :     }
    1798                 :            :     // add outputs
    1799                 :          0 :     AddCoins(inputs, tx, nHeight);
    1800                 :          0 : }
    1801                 :            : 
    1802                 :          0 : bool CScriptCheck::operator()() {
    1803                 :          0 :     const CScript &scriptSig = ptxTo->vin[nIn].scriptSig;
    1804                 :          0 :     const CScriptWitness *witness = &ptxTo->vin[nIn].scriptWitness;
    1805         [ #  # ]:          0 :     return VerifyScript(scriptSig, m_tx_out.scriptPubKey, witness, nFlags, CachingTransactionSignatureChecker(ptxTo, nIn, m_tx_out.nValue, cacheStore, *txdata), &error);
    1806                 :          0 : }
    1807                 :            : 
    1808                 :          2 : static CuckooCache::cache<uint256, SignatureCacheHasher> g_scriptExecutionCache;
    1809                 :          2 : static CSHA256 g_scriptExecutionCacheHasher;
    1810                 :            : 
    1811                 :          1 : bool InitScriptExecutionCache(size_t max_size_bytes)
    1812                 :            : {
    1813                 :            :     // Setup the salted hasher
    1814                 :          1 :     uint256 nonce = GetRandHash();
    1815                 :            :     // We want the nonce to be 64 bytes long to force the hasher to process
    1816                 :            :     // this chunk, which makes later hash computations more efficient. We
    1817                 :            :     // just write our 32-byte entropy twice to fill the 64 bytes.
    1818                 :          1 :     g_scriptExecutionCacheHasher.Write(nonce.begin(), 32);
    1819                 :          1 :     g_scriptExecutionCacheHasher.Write(nonce.begin(), 32);
    1820                 :            : 
    1821                 :          1 :     auto setup_results = g_scriptExecutionCache.setup_bytes(max_size_bytes);
    1822         [ -  + ]:          1 :     if (!setup_results) return false;
    1823                 :            : 
    1824                 :          3 :     const auto [num_elems, approx_size_bytes] = *setup_results;
    1825   [ +  -  +  -  :          1 :     LogPrintf("Using %zu MiB out of %zu MiB requested for script execution cache, able to store %zu elements\n",
             -  +  -  + ]
    1826                 :            :               approx_size_bytes >> 20, max_size_bytes >> 20, num_elems);
    1827                 :          1 :     return true;
    1828                 :          1 : }
    1829                 :            : 
    1830                 :            : /**
    1831                 :            :  * Check whether all of this transaction's input scripts succeed.
    1832                 :            :  *
    1833                 :            :  * This involves ECDSA signature checks so can be computationally intensive. This function should
    1834                 :            :  * only be called after the cheap sanity checks in CheckTxInputs passed.
    1835                 :            :  *
    1836                 :            :  * If pvChecks is not nullptr, script checks are pushed onto it instead of being performed inline. Any
    1837                 :            :  * script checks which are not necessary (eg due to script execution cache hits) are, obviously,
    1838                 :            :  * not pushed onto pvChecks/run.
    1839                 :            :  *
    1840                 :            :  * Setting cacheSigStore/cacheFullScriptStore to false will remove elements from the corresponding cache
    1841                 :            :  * which are matched. This is useful for checking blocks where we will likely never need the cache
    1842                 :            :  * entry again.
    1843                 :            :  *
    1844                 :            :  * Note that we may set state.reason to NOT_STANDARD for extra soft-fork flags in flags, block-checking
    1845                 :            :  * callers should probably reset it to CONSENSUS in such cases.
    1846                 :            :  *
    1847                 :            :  * Non-static (and re-declared) in src/test/txvalidationcache_tests.cpp
    1848                 :            :  */
    1849                 :          0 : bool CheckInputScripts(const CTransaction& tx, TxValidationState& state,
    1850                 :            :                        const CCoinsViewCache& inputs, unsigned int flags, bool cacheSigStore,
    1851                 :            :                        bool cacheFullScriptStore, PrecomputedTransactionData& txdata,
    1852                 :            :                        std::vector<CScriptCheck>* pvChecks)
    1853                 :            : {
    1854         [ #  # ]:          0 :     if (tx.IsCoinBase()) return true;
    1855                 :            : 
    1856         [ #  # ]:          0 :     if (pvChecks) {
    1857                 :          0 :         pvChecks->reserve(tx.vin.size());
    1858                 :          0 :     }
    1859                 :            : 
    1860                 :            :     // First check if script executions have been cached with the same
    1861                 :            :     // flags. Note that this assumes that the inputs provided are
    1862                 :            :     // correct (ie that the transaction hash which is in tx's prevouts
    1863                 :            :     // properly commits to the scriptPubKey in the inputs view of that
    1864                 :            :     // transaction).
    1865                 :          0 :     uint256 hashCacheEntry;
    1866                 :          0 :     CSHA256 hasher = g_scriptExecutionCacheHasher;
    1867                 :          0 :     hasher.Write(tx.GetWitnessHash().begin(), 32).Write((unsigned char*)&flags, sizeof(flags)).Finalize(hashCacheEntry.begin());
    1868                 :          0 :     AssertLockHeld(cs_main); //TODO: Remove this requirement by making CuckooCache not require external locks
    1869         [ #  # ]:          0 :     if (g_scriptExecutionCache.contains(hashCacheEntry, !cacheFullScriptStore)) {
    1870                 :          0 :         return true;
    1871                 :            :     }
    1872                 :            : 
    1873         [ #  # ]:          0 :     if (!txdata.m_spent_outputs_ready) {
    1874                 :          0 :         std::vector<CTxOut> spent_outputs;
    1875         [ #  # ]:          0 :         spent_outputs.reserve(tx.vin.size());
    1876                 :            : 
    1877         [ #  # ]:          0 :         for (const auto& txin : tx.vin) {
    1878                 :          0 :             const COutPoint& prevout = txin.prevout;
    1879         [ #  # ]:          0 :             const Coin& coin = inputs.AccessCoin(prevout);
    1880   [ #  #  #  # ]:          0 :             assert(!coin.IsSpent());
    1881         [ #  # ]:          0 :             spent_outputs.emplace_back(coin.out);
    1882                 :            :         }
    1883         [ #  # ]:          0 :         txdata.Init(tx, std::move(spent_outputs));
    1884                 :          0 :     }
    1885         [ #  # ]:          0 :     assert(txdata.m_spent_outputs.size() == tx.vin.size());
    1886                 :            : 
    1887         [ #  # ]:          0 :     for (unsigned int i = 0; i < tx.vin.size(); i++) {
    1888                 :            : 
    1889                 :            :         // We very carefully only pass in things to CScriptCheck which
    1890                 :            :         // are clearly committed to by tx' witness hash. This provides
    1891                 :            :         // a sanity check that our caching is not introducing consensus
    1892                 :            :         // failures through additional data in, eg, the coins being
    1893                 :            :         // spent being checked as a part of CScriptCheck.
    1894                 :            : 
    1895                 :            :         // Verify signature
    1896                 :          0 :         CScriptCheck check(txdata.m_spent_outputs[i], tx, i, flags, cacheSigStore, &txdata);
    1897         [ #  # ]:          0 :         if (pvChecks) {
    1898         [ #  # ]:          0 :             pvChecks->emplace_back(std::move(check));
    1899   [ #  #  #  # ]:          0 :         } else if (!check()) {
    1900         [ #  # ]:          0 :             if (flags & STANDARD_NOT_MANDATORY_VERIFY_FLAGS) {
    1901                 :            :                 // Check whether the failure was caused by a
    1902                 :            :                 // non-mandatory script verification check, such as
    1903                 :            :                 // non-standard DER encodings or non-null dummy
    1904                 :            :                 // arguments; if so, ensure we return NOT_STANDARD
    1905                 :            :                 // instead of CONSENSUS to avoid downstream users
    1906                 :            :                 // splitting the network between upgraded and
    1907                 :            :                 // non-upgraded nodes by banning CONSENSUS-failing
    1908                 :            :                 // data providers.
    1909   [ #  #  #  # ]:          0 :                 CScriptCheck check2(txdata.m_spent_outputs[i], tx, i,
    1910                 :          0 :                         flags & ~STANDARD_NOT_MANDATORY_VERIFY_FLAGS, cacheSigStore, &txdata);
    1911   [ #  #  #  # ]:          0 :                 if (check2())
    1912   [ #  #  #  #  :          0 :                     return state.Invalid(TxValidationResult::TX_NOT_STANDARD, strprintf("non-mandatory-script-verify-flag (%s)", ScriptErrorString(check.GetScriptError())));
          #  #  #  #  #  
                      # ]
    1913         [ #  # ]:          0 :             }
    1914                 :            :             // MANDATORY flag failures correspond to
    1915                 :            :             // TxValidationResult::TX_CONSENSUS. Because CONSENSUS
    1916                 :            :             // failures are the most serious case of validation
    1917                 :            :             // failures, we may need to consider using
    1918                 :            :             // RECENT_CONSENSUS_CHANGE for any script failure that
    1919                 :            :             // could be due to non-upgraded nodes which we may want to
    1920                 :            :             // support, to avoid splitting the network (but this
    1921                 :            :             // depends on the details of how net_processing handles
    1922                 :            :             // such errors).
    1923   [ #  #  #  #  :          0 :             return state.Invalid(TxValidationResult::TX_CONSENSUS, strprintf("mandatory-script-verify-flag-failed (%s)", ScriptErrorString(check.GetScriptError())));
          #  #  #  #  #  
                      # ]
    1924                 :            :         }
    1925      [ #  #  # ]:          0 :     }
    1926                 :            : 
    1927   [ #  #  #  # ]:          0 :     if (cacheFullScriptStore && !pvChecks) {
    1928                 :            :         // We executed all of the provided scripts, and were told to
    1929                 :            :         // cache the result. Do so now.
    1930                 :          0 :         g_scriptExecutionCache.insert(hashCacheEntry);
    1931                 :          0 :     }
    1932                 :            : 
    1933                 :          0 :     return true;
    1934                 :          0 : }
    1935                 :            : 
    1936                 :          0 : bool FatalError(Notifications& notifications, BlockValidationState& state, const std::string& strMessage, const bilingual_str& userMessage)
    1937                 :            : {
    1938                 :          0 :     notifications.fatalError(strMessage, userMessage);
    1939                 :          0 :     return state.Error(strMessage);
    1940                 :            : }
    1941                 :            : 
    1942                 :            : /**
    1943                 :            :  * Restore the UTXO in a Coin at a given COutPoint
    1944                 :            :  * @param undo The Coin to be restored.
    1945                 :            :  * @param view The coins view to which to apply the changes.
    1946                 :            :  * @param out The out point that corresponds to the tx input.
    1947                 :            :  * @return A DisconnectResult as an int
    1948                 :            :  */
    1949                 :          0 : int ApplyTxInUndo(Coin&& undo, CCoinsViewCache& view, const COutPoint& out)
    1950                 :            : {
    1951                 :          0 :     bool fClean = true;
    1952                 :            : 
    1953         [ #  # ]:          0 :     if (view.HaveCoin(out)) fClean = false; // overwriting transaction output
    1954                 :            : 
    1955         [ #  # ]:          0 :     if (undo.nHeight == 0) {
    1956                 :            :         // Missing undo metadata (height and coinbase). Older versions included this
    1957                 :            :         // information only in undo records for the last spend of a transactions'
    1958                 :            :         // outputs. This implies that it must be present for some other output of the same tx.
    1959                 :          0 :         const Coin& alternate = AccessByTxid(view, out.hash);
    1960         [ #  # ]:          0 :         if (!alternate.IsSpent()) {
    1961                 :          0 :             undo.nHeight = alternate.nHeight;
    1962                 :          0 :             undo.fCoinBase = alternate.fCoinBase;
    1963                 :          0 :         } else {
    1964                 :          0 :             return DISCONNECT_FAILED; // adding output for transaction without known metadata
    1965                 :            :         }
    1966                 :          0 :     }
    1967                 :            :     // If the coin already exists as an unspent coin in the cache, then the
    1968                 :            :     // possible_overwrite parameter to AddCoin must be set to true. We have
    1969                 :            :     // already checked whether an unspent coin exists above using HaveCoin, so
    1970                 :            :     // we don't need to guess. When fClean is false, an unspent coin already
    1971                 :            :     // existed and it is an overwrite.
    1972                 :          0 :     view.AddCoin(out, std::move(undo), !fClean);
    1973                 :            : 
    1974                 :          0 :     return fClean ? DISCONNECT_OK : DISCONNECT_UNCLEAN;
    1975                 :          0 : }
    1976                 :            : 
    1977                 :            : /** Undo the effects of this block (with given index) on the UTXO set represented by coins.
    1978                 :            :  *  When FAILED is returned, view is left in an indeterminate state. */
    1979                 :          0 : DisconnectResult Chainstate::DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view)
    1980                 :            : {
    1981                 :          0 :     AssertLockHeld(::cs_main);
    1982                 :          0 :     bool fClean = true;
    1983                 :            : 
    1984                 :          0 :     CBlockUndo blockUndo;
    1985   [ #  #  #  # ]:          0 :     if (!m_blockman.UndoReadFromDisk(blockUndo, *pindex)) {
    1986         [ #  # ]:          0 :         error("DisconnectBlock(): failure reading undo data");
    1987                 :          0 :         return DISCONNECT_FAILED;
    1988                 :            :     }
    1989                 :            : 
    1990         [ #  # ]:          0 :     if (blockUndo.vtxundo.size() + 1 != block.vtx.size()) {
    1991         [ #  # ]:          0 :         error("DisconnectBlock(): block and undo data inconsistent");
    1992                 :          0 :         return DISCONNECT_FAILED;
    1993                 :            :     }
    1994                 :            : 
    1995                 :            :     // Ignore blocks that contain transactions which are 'overwritten' by later transactions,
    1996                 :            :     // unless those are already completely spent.
    1997                 :            :     // See https://github.com/bitcoin/bitcoin/issues/22596 for additional information.
    1998                 :            :     // Note: the blocks specified here are different than the ones used in ConnectBlock because DisconnectBlock
    1999                 :            :     // unwinds the blocks in reverse. As a result, the inconsistency is not discovered until the earlier
    2000                 :            :     // blocks with the duplicate coinbase transactions are disconnected.
    2001   [ #  #  #  #  :          0 :     bool fEnforceBIP30 = !((pindex->nHeight==91722 && pindex->GetBlockHash() == uint256S("0x00000000000271a2dc26e7667f8419f2e15416dc6955e5a6c6cdf3f2574dd08e")) ||
          #  #  #  #  #  
                      # ]
    2002   [ #  #  #  #  :          0 :                            (pindex->nHeight==91812 && pindex->GetBlockHash() == uint256S("0x00000000000af0aed4792b1acee3d966af36cf5def14935db8de83d6f9306f2f")));
             #  #  #  # ]
    2003                 :            : 
    2004                 :            :     // undo transactions in reverse order
    2005         [ #  # ]:          0 :     for (int i = block.vtx.size() - 1; i >= 0; i--) {
    2006                 :          0 :         const CTransaction &tx = *(block.vtx[i]);
    2007         [ #  # ]:          0 :         uint256 hash = tx.GetHash();
    2008         [ #  # ]:          0 :         bool is_coinbase = tx.IsCoinBase();
    2009         [ #  # ]:          0 :         bool is_bip30_exception = (is_coinbase && !fEnforceBIP30);
    2010                 :            : 
    2011                 :            :         // Check that all outputs are available and match the outputs in the block itself
    2012                 :            :         // exactly.
    2013         [ #  # ]:          0 :         for (size_t o = 0; o < tx.vout.size(); o++) {
    2014   [ #  #  #  # ]:          0 :             if (!tx.vout[o].scriptPubKey.IsUnspendable()) {
    2015         [ #  # ]:          0 :                 COutPoint out(hash, o);
    2016         [ #  # ]:          0 :                 Coin coin;
    2017         [ #  # ]:          0 :                 bool is_spent = view.SpendCoin(out, &coin);
    2018   [ #  #  #  #  :          0 :                 if (!is_spent || tx.vout[o] != coin.out || pindex->nHeight != coin.nHeight || is_coinbase != coin.fCoinBase) {
          #  #  #  #  #  
                      # ]
    2019         [ #  # ]:          0 :                     if (!is_bip30_exception) {
    2020                 :          0 :                         fClean = false; // transaction output mismatch
    2021                 :          0 :                     }
    2022                 :          0 :                 }
    2023                 :          0 :             }
    2024                 :          0 :         }
    2025                 :            : 
    2026                 :            :         // restore inputs
    2027         [ #  # ]:          0 :         if (i > 0) { // not coinbases
    2028                 :          0 :             CTxUndo &txundo = blockUndo.vtxundo[i-1];
    2029         [ #  # ]:          0 :             if (txundo.vprevout.size() != tx.vin.size()) {
    2030         [ #  # ]:          0 :                 error("DisconnectBlock(): transaction and undo data inconsistent");
    2031                 :          0 :                 return DISCONNECT_FAILED;
    2032                 :            :             }
    2033         [ #  # ]:          0 :             for (unsigned int j = tx.vin.size(); j > 0;) {
    2034                 :          0 :                 --j;
    2035                 :          0 :                 const COutPoint& out = tx.vin[j].prevout;
    2036         [ #  # ]:          0 :                 int res = ApplyTxInUndo(std::move(txundo.vprevout[j]), view, out);
    2037         [ #  # ]:          0 :                 if (res == DISCONNECT_FAILED) return DISCONNECT_FAILED;
    2038         [ #  # ]:          0 :                 fClean = fClean && res != DISCONNECT_UNCLEAN;
    2039                 :            :             }
    2040                 :            :             // At this point, all of txundo.vprevout should have been moved out.
    2041                 :          0 :         }
    2042                 :          0 :     }
    2043                 :            : 
    2044                 :            :     // move best block pointer to prevout block
    2045   [ #  #  #  # ]:          0 :     view.SetBestBlock(pindex->pprev->GetBlockHash());
    2046                 :            : 
    2047                 :          0 :     return fClean ? DISCONNECT_OK : DISCONNECT_UNCLEAN;
    2048                 :          0 : }
    2049                 :            : 
    2050                 :          2 : static CCheckQueue<CScriptCheck> scriptcheckqueue(128);
    2051                 :            : 
    2052                 :          1 : void StartScriptCheckWorkerThreads(int threads_num)
    2053                 :            : {
    2054                 :          1 :     scriptcheckqueue.StartWorkerThreads(threads_num);
    2055                 :          1 : }
    2056                 :            : 
    2057                 :          1 : void StopScriptCheckWorkerThreads()
    2058                 :            : {
    2059                 :          1 :     scriptcheckqueue.StopWorkerThreads();
    2060                 :          1 : }
    2061                 :            : 
    2062                 :            : /**
    2063                 :            :  * Threshold condition checker that triggers when unknown versionbits are seen on the network.
    2064                 :            :  */
    2065                 :            : class WarningBitsConditionChecker : public AbstractThresholdConditionChecker
    2066                 :            : {
    2067                 :            : private:
    2068                 :            :     const ChainstateManager& m_chainman;
    2069                 :            :     int m_bit;
    2070                 :            : 
    2071                 :            : public:
    2072                 :          0 :     explicit WarningBitsConditionChecker(const ChainstateManager& chainman, int bit) : m_chainman{chainman}, m_bit(bit) {}
    2073                 :            : 
    2074                 :          0 :     int64_t BeginTime(const Consensus::Params& params) const override { return 0; }
    2075                 :          0 :     int64_t EndTime(const Consensus::Params& params) const override { return std::numeric_limits<int64_t>::max(); }
    2076                 :          0 :     int Period(const Consensus::Params& params) const override { return params.nMinerConfirmationWindow; }
    2077                 :          0 :     int Threshold(const Consensus::Params& params) const override { return params.nRuleChangeActivationThreshold; }
    2078                 :            : 
    2079                 :          0 :     bool Condition(const CBlockIndex* pindex, const Consensus::Params& params) const override
    2080                 :            :     {
    2081         [ #  # ]:          0 :         return pindex->nHeight >= params.MinBIP9WarningHeight &&
    2082         [ #  # ]:          0 :                ((pindex->nVersion & VERSIONBITS_TOP_MASK) == VERSIONBITS_TOP_BITS) &&
    2083         [ #  # ]:          0 :                ((pindex->nVersion >> m_bit) & 1) != 0 &&
    2084                 :          0 :                ((m_chainman.m_versionbitscache.ComputeBlockVersion(pindex->pprev, params) >> m_bit) & 1) == 0;
    2085                 :            :     }
    2086                 :            : };
    2087                 :            : 
    2088                 :          0 : static unsigned int GetBlockScriptFlags(const CBlockIndex& block_index, const ChainstateManager& chainman)
    2089                 :            : {
    2090                 :          0 :     const Consensus::Params& consensusparams = chainman.GetConsensus();
    2091                 :            : 
    2092                 :            :     // BIP16 didn't become active until Apr 1 2012 (on mainnet, and
    2093                 :            :     // retroactively applied to testnet)
    2094                 :            :     // However, only one historical block violated the P2SH rules (on both
    2095                 :            :     // mainnet and testnet).
    2096                 :            :     // Similarly, only one historical block violated the TAPROOT rules on
    2097                 :            :     // mainnet.
    2098                 :            :     // For simplicity, always leave P2SH+WITNESS+TAPROOT on except for the two
    2099                 :            :     // violating blocks.
    2100                 :          0 :     uint32_t flags{SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_TAPROOT};
    2101                 :          0 :     const auto it{consensusparams.script_flag_exceptions.find(*Assert(block_index.phashBlock))};
    2102         [ #  # ]:          0 :     if (it != consensusparams.script_flag_exceptions.end()) {
    2103                 :          0 :         flags = it->second;
    2104                 :          0 :     }
    2105                 :            : 
    2106                 :            :     // Enforce the DERSIG (BIP66) rule
    2107         [ #  # ]:          0 :     if (DeploymentActiveAt(block_index, chainman, Consensus::DEPLOYMENT_DERSIG)) {
    2108                 :          0 :         flags |= SCRIPT_VERIFY_DERSIG;
    2109                 :          0 :     }
    2110                 :            : 
    2111                 :            :     // Enforce CHECKLOCKTIMEVERIFY (BIP65)
    2112         [ #  # ]:          0 :     if (DeploymentActiveAt(block_index, chainman, Consensus::DEPLOYMENT_CLTV)) {
    2113                 :          0 :         flags |= SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY;
    2114                 :          0 :     }
    2115                 :            : 
    2116                 :            :     // Enforce CHECKSEQUENCEVERIFY (BIP112)
    2117         [ #  # ]:          0 :     if (DeploymentActiveAt(block_index, chainman, Consensus::DEPLOYMENT_CSV)) {
    2118                 :          0 :         flags |= SCRIPT_VERIFY_CHECKSEQUENCEVERIFY;
    2119                 :          0 :     }
    2120                 :            : 
    2121                 :            :     // Enforce BIP147 NULLDUMMY (activated simultaneously with segwit)
    2122         [ #  # ]:          0 :     if (DeploymentActiveAt(block_index, chainman, Consensus::DEPLOYMENT_SEGWIT)) {
    2123                 :          0 :         flags |= SCRIPT_VERIFY_NULLDUMMY;
    2124                 :          0 :     }
    2125                 :            : 
    2126                 :          0 :     return flags;
    2127                 :            : }
    2128                 :            : 
    2129                 :            : 
    2130                 :            : static SteadyClock::duration time_check{};
    2131                 :            : static SteadyClock::duration time_forks{};
    2132                 :            : static SteadyClock::duration time_connect{};
    2133                 :            : static SteadyClock::duration time_verify{};
    2134                 :            : static SteadyClock::duration time_undo{};
    2135                 :            : static SteadyClock::duration time_index{};
    2136                 :            : static SteadyClock::duration time_total{};
    2137                 :            : static int64_t num_blocks_total = 0;
    2138                 :            : 
    2139                 :            : /** Apply the effects of this block (with given index) on the UTXO set represented by coins.
    2140                 :            :  *  Validity checks that depend on the UTXO set are also done; ConnectBlock()
    2141                 :            :  *  can fail if those validity checks fail (among other reasons). */
    2142                 :          1 : bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state, CBlockIndex* pindex,
    2143                 :            :                                CCoinsViewCache& view, bool fJustCheck)
    2144                 :            : {
    2145                 :          1 :     AssertLockHeld(cs_main);
    2146         [ +  - ]:          1 :     assert(pindex);
    2147                 :            : 
    2148                 :          1 :     uint256 block_hash{block.GetHash()};
    2149         [ +  - ]:          1 :     assert(*pindex->phashBlock == block_hash);
    2150                 :          1 :     const bool parallel_script_checks{scriptcheckqueue.HasThreads()};
    2151                 :            : 
    2152                 :          1 :     const auto time_start{SteadyClock::now()};
    2153                 :          1 :     const CChainParams& params{m_chainman.GetParams()};
    2154                 :            : 
    2155                 :            :     // Check it again in case a previous version let a bad block in
    2156                 :            :     // NOTE: We don't currently (re-)invoke ContextualCheckBlock() or
    2157                 :            :     // ContextualCheckBlockHeader() here. This means that if we add a new
    2158                 :            :     // consensus rule that is enforced in one of those two functions, then we
    2159                 :            :     // may have let in a block that violates the rule prior to updating the
    2160                 :            :     // software, and we would NOT be enforcing the rule here. Fully solving
    2161                 :            :     // upgrade from one software version to the next after a consensus rule
    2162                 :            :     // change is potentially tricky and issue-specific (see NeedsRedownload()
    2163                 :            :     // for one approach that was used for BIP 141 deployment).
    2164                 :            :     // Also, currently the rule against blocks more than 2 hours in the future
    2165                 :            :     // is enforced in ContextualCheckBlockHeader(); we wouldn't want to
    2166                 :            :     // re-enforce that rule here (at least until we make it impossible for
    2167                 :            :     // m_adjusted_time_callback() to go backward).
    2168         [ +  - ]:          1 :     if (!CheckBlock(block, state, params.GetConsensus(), !fJustCheck, !fJustCheck)) {
    2169         [ #  # ]:          0 :         if (state.GetResult() == BlockValidationResult::BLOCK_MUTATED) {
    2170                 :            :             // We don't write down blocks to disk if they may have been
    2171                 :            :             // corrupted, so this should be impossible unless we're having hardware
    2172                 :            :             // problems.
    2173   [ #  #  #  # ]:          0 :             return FatalError(m_chainman.GetNotifications(), state, "Corrupt block found indicating potential hardware failure; shutting down");
    2174                 :            :         }
    2175         [ #  # ]:          0 :         return error("%s: Consensus::CheckBlock: %s", __func__, state.ToString());
    2176                 :            :     }
    2177                 :            : 
    2178                 :            :     // verify that the view's current state corresponds to the previous block
    2179         [ -  + ]:          1 :     uint256 hashPrevBlock = pindex->pprev == nullptr ? uint256() : pindex->pprev->GetBlockHash();
    2180         [ +  - ]:          1 :     assert(hashPrevBlock == view.GetBestBlock());
    2181                 :            : 
    2182                 :          1 :     num_blocks_total++;
    2183                 :            : 
    2184                 :            :     // Special case for the genesis block, skipping connection of its transactions
    2185                 :            :     // (its coinbase is unspendable)
    2186         [ +  - ]:          1 :     if (block_hash == params.GetConsensus().hashGenesisBlock) {
    2187         [ -  + ]:          1 :         if (!fJustCheck)
    2188                 :          1 :             view.SetBestBlock(pindex->GetBlockHash());
    2189                 :          1 :         return true;
    2190                 :            :     }
    2191                 :            : 
    2192                 :          0 :     bool fScriptChecks = true;
    2193         [ #  # ]:          0 :     if (!m_chainman.AssumedValidBlock().IsNull()) {
    2194                 :            :         // We've been configured with the hash of a block which has been externally verified to have a valid history.
    2195                 :            :         // A suitable default value is included with the software and updated from time to time.  Because validity
    2196                 :            :         //  relative to a piece of software is an objective fact these defaults can be easily reviewed.
    2197                 :            :         // This setting doesn't force the selection of any particular chain but makes validating some faster by
    2198                 :            :         //  effectively caching the result of part of the verification.
    2199                 :          0 :         BlockMap::const_iterator it{m_blockman.m_block_index.find(m_chainman.AssumedValidBlock())};
    2200         [ #  # ]:          0 :         if (it != m_blockman.m_block_index.end()) {
    2201   [ #  #  #  # ]:          0 :             if (it->second.GetAncestor(pindex->nHeight) == pindex &&
    2202         [ #  # ]:          0 :                 m_chainman.m_best_header->GetAncestor(pindex->nHeight) == pindex &&
    2203                 :          0 :                 m_chainman.m_best_header->nChainWork >= m_chainman.MinimumChainWork()) {
    2204                 :            :                 // This block is a member of the assumed verified chain and an ancestor of the best header.
    2205                 :            :                 // Script verification is skipped when connecting blocks under the
    2206                 :            :                 // assumevalid block. Assuming the assumevalid block is valid this
    2207                 :            :                 // is safe because block merkle hashes are still computed and checked,
    2208                 :            :                 // Of course, if an assumed valid block is invalid due to false scriptSigs
    2209                 :            :                 // this optimization would allow an invalid chain to be accepted.
    2210                 :            :                 // The equivalent time check discourages hash power from extorting the network via DOS attack
    2211                 :            :                 //  into accepting an invalid block through telling users they must manually set assumevalid.
    2212                 :            :                 //  Requiring a software change or burying the invalid block, regardless of the setting, makes
    2213                 :            :                 //  it hard to hide the implication of the demand.  This also avoids having release candidates
    2214                 :            :                 //  that are hardly doing any signature verification at all in testing without having to
    2215                 :            :                 //  artificially set the default assumed verified block further back.
    2216                 :            :                 // The test against the minimum chain work prevents the skipping when denied access to any chain at
    2217                 :            :                 //  least as good as the expected chain.
    2218                 :          0 :                 fScriptChecks = (GetBlockProofEquivalentTime(*m_chainman.m_best_header, *pindex, *m_chainman.m_best_header, params.GetConsensus()) <= 60 * 60 * 24 * 7 * 2);
    2219                 :          0 :             }
    2220                 :          0 :         }
    2221                 :          0 :     }
    2222                 :            : 
    2223                 :          0 :     const auto time_1{SteadyClock::now()};
    2224                 :          0 :     time_check += time_1 - time_start;
    2225   [ #  #  #  #  :          0 :     LogPrint(BCLog::BENCH, "    - Sanity checks: %.2fms [%.2fs (%.2fms/blk)]\n",
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    2226                 :            :              Ticks<MillisecondsDouble>(time_1 - time_start),
    2227                 :            :              Ticks<SecondsDouble>(time_check),
    2228                 :            :              Ticks<MillisecondsDouble>(time_check) / num_blocks_total);
    2229                 :            : 
    2230                 :            :     // Do not allow blocks that contain transactions which 'overwrite' older transactions,
    2231                 :            :     // unless those are already completely spent.
    2232                 :            :     // If such overwrites are allowed, coinbases and transactions depending upon those
    2233                 :            :     // can be duplicated to remove the ability to spend the first instance -- even after
    2234                 :            :     // being sent to another address.
    2235                 :            :     // See BIP30, CVE-2012-1909, and http://r6.ca/blog/20120206T005236Z.html for more information.
    2236                 :            :     // This rule was originally applied to all blocks with a timestamp after March 15, 2012, 0:00 UTC.
    2237                 :            :     // Now that the whole chain is irreversibly beyond that time it is applied to all blocks except the
    2238                 :            :     // two in the chain that violate it. This prevents exploiting the issue against nodes during their
    2239                 :            :     // initial block download.
    2240                 :          0 :     bool fEnforceBIP30 = !IsBIP30Repeat(*pindex);
    2241                 :            : 
    2242                 :            :     // Once BIP34 activated it was not possible to create new duplicate coinbases and thus other than starting
    2243                 :            :     // with the 2 existing duplicate coinbase pairs, not possible to create overwriting txs.  But by the
    2244                 :            :     // time BIP34 activated, in each of the existing pairs the duplicate coinbase had overwritten the first
    2245                 :            :     // before the first had been spent.  Since those coinbases are sufficiently buried it's no longer possible to create further
    2246                 :            :     // duplicate transactions descending from the known pairs either.
    2247                 :            :     // If we're on the known chain at height greater than where BIP34 activated, we can save the db accesses needed for the BIP30 check.
    2248                 :            : 
    2249                 :            :     // BIP34 requires that a block at height X (block X) has its coinbase
    2250                 :            :     // scriptSig start with a CScriptNum of X (indicated height X).  The above
    2251                 :            :     // logic of no longer requiring BIP30 once BIP34 activates is flawed in the
    2252                 :            :     // case that there is a block X before the BIP34 height of 227,931 which has
    2253                 :            :     // an indicated height Y where Y is greater than X.  The coinbase for block
    2254                 :            :     // X would also be a valid coinbase for block Y, which could be a BIP30
    2255                 :            :     // violation.  An exhaustive search of all mainnet coinbases before the
    2256                 :            :     // BIP34 height which have an indicated height greater than the block height
    2257                 :            :     // reveals many occurrences. The 3 lowest indicated heights found are
    2258                 :            :     // 209,921, 490,897, and 1,983,702 and thus coinbases for blocks at these 3
    2259                 :            :     // heights would be the first opportunity for BIP30 to be violated.
    2260                 :            : 
    2261                 :            :     // The search reveals a great many blocks which have an indicated height
    2262                 :            :     // greater than 1,983,702, so we simply remove the optimization to skip
    2263                 :            :     // BIP30 checking for blocks at height 1,983,702 or higher.  Before we reach
    2264                 :            :     // that block in another 25 years or so, we should take advantage of a
    2265                 :            :     // future consensus change to do a new and improved version of BIP34 that
    2266                 :            :     // will actually prevent ever creating any duplicate coinbases in the
    2267                 :            :     // future.
    2268                 :            :     static constexpr int BIP34_IMPLIES_BIP30_LIMIT = 1983702;
    2269                 :            : 
    2270                 :            :     // There is no potential to create a duplicate coinbase at block 209,921
    2271                 :            :     // because this is still before the BIP34 height and so explicit BIP30
    2272                 :            :     // checking is still active.
    2273                 :            : 
    2274                 :            :     // The final case is block 176,684 which has an indicated height of
    2275                 :            :     // 490,897. Unfortunately, this issue was not discovered until about 2 weeks
    2276                 :            :     // before block 490,897 so there was not much opportunity to address this
    2277                 :            :     // case other than to carefully analyze it and determine it would not be a
    2278                 :            :     // problem. Block 490,897 was, in fact, mined with a different coinbase than
    2279                 :            :     // block 176,684, but it is important to note that even if it hadn't been or
    2280                 :            :     // is remined on an alternate fork with a duplicate coinbase, we would still
    2281                 :            :     // not run into a BIP30 violation.  This is because the coinbase for 176,684
    2282                 :            :     // is spent in block 185,956 in transaction
    2283                 :            :     // d4f7fbbf92f4a3014a230b2dc70b8058d02eb36ac06b4a0736d9d60eaa9e8781.  This
    2284                 :            :     // spending transaction can't be duplicated because it also spends coinbase
    2285                 :            :     // 0328dd85c331237f18e781d692c92de57649529bd5edf1d01036daea32ffde29.  This
    2286                 :            :     // coinbase has an indicated height of over 4.2 billion, and wouldn't be
    2287                 :            :     // duplicatable until that height, and it's currently impossible to create a
    2288                 :            :     // chain that long. Nevertheless we may wish to consider a future soft fork
    2289                 :            :     // which retroactively prevents block 490,897 from creating a duplicate
    2290                 :            :     // coinbase. The two historical BIP30 violations often provide a confusing
    2291                 :            :     // edge case when manipulating the UTXO and it would be simpler not to have
    2292                 :            :     // another edge case to deal with.
    2293                 :            : 
    2294                 :            :     // testnet3 has no blocks before the BIP34 height with indicated heights
    2295                 :            :     // post BIP34 before approximately height 486,000,000. After block
    2296                 :            :     // 1,983,702 testnet3 starts doing unnecessary BIP30 checking again.
    2297         [ #  # ]:          0 :     assert(pindex->pprev);
    2298                 :          0 :     CBlockIndex* pindexBIP34height = pindex->pprev->GetAncestor(params.GetConsensus().BIP34Height);
    2299                 :            :     //Only continue to enforce if we're below BIP34 activation height or the block hash at that height doesn't correspond.
    2300   [ #  #  #  # ]:          0 :     fEnforceBIP30 = fEnforceBIP30 && (!pindexBIP34height || !(pindexBIP34height->GetBlockHash() == params.GetConsensus().BIP34Hash));
    2301                 :            : 
    2302                 :            :     // TODO: Remove BIP30 checking from block height 1,983,702 on, once we have a
    2303                 :            :     // consensus change that ensures coinbases at those heights cannot
    2304                 :            :     // duplicate earlier coinbases.
    2305   [ #  #  #  # ]:          0 :     if (fEnforceBIP30 || pindex->nHeight >= BIP34_IMPLIES_BIP30_LIMIT) {
    2306         [ #  # ]:          0 :         for (const auto& tx : block.vtx) {
    2307         [ #  # ]:          0 :             for (size_t o = 0; o < tx->vout.size(); o++) {
    2308         [ #  # ]:          0 :                 if (view.HaveCoin(COutPoint(tx->GetHash(), o))) {
    2309   [ #  #  #  #  :          0 :                     LogPrintf("ERROR: ConnectBlock(): tried to overwrite transaction\n");
                   #  # ]
    2310   [ #  #  #  #  :          0 :                     return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-txns-BIP30");
                   #  # ]
    2311                 :            :                 }
    2312                 :          0 :             }
    2313                 :            :         }
    2314                 :          0 :     }
    2315                 :            : 
    2316                 :            :     // Enforce BIP68 (sequence locks)
    2317                 :          0 :     int nLockTimeFlags = 0;
    2318         [ #  # ]:          0 :     if (DeploymentActiveAt(*pindex, m_chainman, Consensus::DEPLOYMENT_CSV)) {
    2319                 :          0 :         nLockTimeFlags |= LOCKTIME_VERIFY_SEQUENCE;
    2320                 :          0 :     }
    2321                 :            : 
    2322                 :            :     // Get the script flags for this block
    2323                 :          0 :     unsigned int flags{GetBlockScriptFlags(*pindex, m_chainman)};
    2324                 :            : 
    2325                 :          0 :     const auto time_2{SteadyClock::now()};
    2326                 :          0 :     time_forks += time_2 - time_1;
    2327   [ #  #  #  #  :          0 :     LogPrint(BCLog::BENCH, "    - Fork checks: %.2fms [%.2fs (%.2fms/blk)]\n",
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    2328                 :            :              Ticks<MillisecondsDouble>(time_2 - time_1),
    2329                 :            :              Ticks<SecondsDouble>(time_forks),
    2330                 :            :              Ticks<MillisecondsDouble>(time_forks) / num_blocks_total);
    2331                 :            : 
    2332                 :          0 :     CBlockUndo blockundo;
    2333                 :            : 
    2334                 :            :     // Precomputed transaction data pointers must not be invalidated
    2335                 :            :     // until after `control` has run the script checks (potentially
    2336                 :            :     // in multiple threads). Preallocate the vector size so a new allocation
    2337                 :            :     // doesn't invalidate pointers into the vector, and keep txsdata in scope
    2338                 :            :     // for as long as `control`.
    2339   [ #  #  #  # ]:          0 :     CCheckQueueControl<CScriptCheck> control(fScriptChecks && parallel_script_checks ? &scriptcheckqueue : nullptr);
    2340         [ #  # ]:          0 :     std::vector<PrecomputedTransactionData> txsdata(block.vtx.size());
    2341                 :            : 
    2342                 :          0 :     std::vector<int> prevheights;
    2343                 :          0 :     CAmount nFees = 0;
    2344                 :          0 :     int nInputs = 0;
    2345                 :          0 :     int64_t nSigOpsCost = 0;
    2346         [ #  # ]:          0 :     blockundo.vtxundo.reserve(block.vtx.size() - 1);
    2347         [ #  # ]:          0 :     for (unsigned int i = 0; i < block.vtx.size(); i++)
    2348                 :            :     {
    2349                 :          0 :         const CTransaction &tx = *(block.vtx[i]);
    2350                 :            : 
    2351                 :          0 :         nInputs += tx.vin.size();
    2352                 :            : 
    2353   [ #  #  #  # ]:          0 :         if (!tx.IsCoinBase())
    2354                 :            :         {
    2355                 :          0 :             CAmount txfee = 0;
    2356                 :          0 :             TxValidationState tx_state;
    2357   [ #  #  #  # ]:          0 :             if (!Consensus::CheckTxInputs(tx, tx_state, view, pindex->nHeight, txfee)) {
    2358                 :            :                 // Any transaction validation failure in ConnectBlock is a block consensus failure
    2359         [ #  # ]:          0 :                 state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
    2360   [ #  #  #  # ]:          0 :                             tx_state.GetRejectReason(), tx_state.GetDebugMessage());
    2361   [ #  #  #  #  :          0 :                 return error("%s: Consensus::CheckTxInputs: %s, %s", __func__, tx.GetHash().ToString(), state.ToString());
             #  #  #  # ]
    2362                 :            :             }
    2363                 :          0 :             nFees += txfee;
    2364   [ #  #  #  # ]:          0 :             if (!MoneyRange(nFees)) {
    2365   [ #  #  #  #  :          0 :                 LogPrintf("ERROR: %s: accumulated fee in the block out of range.\n", __func__);
                   #  # ]
    2366   [ #  #  #  #  :          0 :                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-txns-accumulated-fee-outofrange");
                   #  # ]
    2367                 :            :             }
    2368                 :            : 
    2369                 :            :             // Check that transaction is BIP68 final
    2370                 :            :             // BIP68 lock checks (as opposed to nLockTime checks) must
    2371                 :            :             // be in ConnectBlock because they require the UTXO set
    2372         [ #  # ]:          0 :             prevheights.resize(tx.vin.size());
    2373         [ #  # ]:          0 :             for (size_t j = 0; j < tx.vin.size(); j++) {
    2374         [ #  # ]:          0 :                 prevheights[j] = view.AccessCoin(tx.vin[j].prevout).nHeight;
    2375                 :          0 :             }
    2376                 :            : 
    2377   [ #  #  #  # ]:          0 :             if (!SequenceLocks(tx, nLockTimeFlags, prevheights, *pindex)) {
    2378   [ #  #  #  #  :          0 :                 LogPrintf("ERROR: %s: contains a non-BIP68-final transaction\n", __func__);
                   #  # ]
    2379   [ #  #  #  #  :          0 :                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-txns-nonfinal");
                   #  # ]
    2380                 :            :             }
    2381         [ #  # ]:          0 :         }
    2382                 :            : 
    2383                 :            :         // GetTransactionSigOpCost counts 3 types of sigops:
    2384                 :            :         // * legacy (always)
    2385                 :            :         // * p2sh (when P2SH enabled in flags and excludes coinbase)
    2386                 :            :         // * witness (when witness enabled in flags and excludes coinbase)
    2387         [ #  # ]:          0 :         nSigOpsCost += GetTransactionSigOpCost(tx, view, flags);
    2388         [ #  # ]:          0 :         if (nSigOpsCost > MAX_BLOCK_SIGOPS_COST) {
    2389   [ #  #  #  #  :          0 :             LogPrintf("ERROR: ConnectBlock(): too many sigops\n");
                   #  # ]
    2390   [ #  #  #  #  :          0 :             return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-blk-sigops");
                   #  # ]
    2391                 :            :         }
    2392                 :            : 
    2393   [ #  #  #  # ]:          0 :         if (!tx.IsCoinBase())
    2394                 :            :         {
    2395                 :          0 :             std::vector<CScriptCheck> vChecks;
    2396                 :          0 :             bool fCacheResults = fJustCheck; /* Don't cache results if we're actually connecting blocks (still consult the cache, though) */
    2397                 :          0 :             TxValidationState tx_state;
    2398   [ #  #  #  #  :          0 :             if (fScriptChecks && !CheckInputScripts(tx, tx_state, view, flags, fCacheResults, fCacheResults, txsdata[i], parallel_script_checks ? &vChecks : nullptr)) {
             #  #  #  # ]
    2399                 :            :                 // Any transaction validation failure in ConnectBlock is a block consensus failure
    2400         [ #  # ]:          0 :                 state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
    2401   [ #  #  #  # ]:          0 :                               tx_state.GetRejectReason(), tx_state.GetDebugMessage());
    2402         [ #  # ]:          0 :                 return error("ConnectBlock(): CheckInputScripts on %s failed with %s",
    2403   [ #  #  #  #  :          0 :                     tx.GetHash().ToString(), state.ToString());
                   #  # ]
    2404                 :            :             }
    2405         [ #  # ]:          0 :             control.Add(std::move(vChecks));
    2406         [ #  # ]:          0 :         }
    2407                 :            : 
    2408                 :          0 :         CTxUndo undoDummy;
    2409         [ #  # ]:          0 :         if (i > 0) {
    2410         [ #  # ]:          0 :             blockundo.vtxundo.push_back(CTxUndo());
    2411                 :          0 :         }
    2412   [ #  #  #  # ]:          0 :         UpdateCoins(tx, view, i == 0 ? undoDummy : blockundo.vtxundo.back(), pindex->nHeight);
    2413                 :          0 :     }
    2414                 :          0 :     const auto time_3{SteadyClock::now()};
    2415   [ #  #  #  # ]:          0 :     time_connect += time_3 - time_2;
    2416   [ #  #  #  #  :          0 :     LogPrint(BCLog::BENCH, "      - Connect %u transactions: %.2fms (%.3fms/tx, %.3fms/txin) [%.2fs (%.2fms/blk)]\n", (unsigned)block.vtx.size(),
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
    2417                 :            :              Ticks<MillisecondsDouble>(time_3 - time_2), Ticks<MillisecondsDouble>(time_3 - time_2) / block.vtx.size(),
    2418                 :            :              nInputs <= 1 ? 0 : Ticks<MillisecondsDouble>(time_3 - time_2) / (nInputs - 1),
    2419                 :            :              Ticks<SecondsDouble>(time_connect),
    2420                 :            :              Ticks<MillisecondsDouble>(time_connect) / num_blocks_total);
    2421                 :            : 
    2422         [ #  # ]:          0 :     CAmount blockReward = nFees + GetBlockSubsidy(pindex->nHeight, params.GetConsensus());
    2423   [ #  #  #  # ]:          0 :     if (block.vtx[0]->GetValueOut() > blockReward) {
    2424   [ #  #  #  #  :          0 :         LogPrintf("ERROR: ConnectBlock(): coinbase pays too much (actual=%d vs limit=%d)\n", block.vtx[0]->GetValueOut(), blockReward);
             #  #  #  # ]
    2425   [ #  #  #  #  :          0 :         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-cb-amount");
                   #  # ]
    2426                 :            :     }
    2427                 :            : 
    2428   [ #  #  #  # ]:          0 :     if (!control.Wait()) {
    2429   [ #  #  #  #  :          0 :         LogPrintf("ERROR: %s: CheckQueue failed\n", __func__);
                   #  # ]
    2430   [ #  #  #  #  :          0 :         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "block-validation-failed");
                   #  # ]
    2431                 :            :     }
    2432                 :          0 :     const auto time_4{SteadyClock::now()};
    2433   [ #  #  #  # ]:          0 :     time_verify += time_4 - time_2;
    2434   [ #  #  #  #  :          0 :     LogPrint(BCLog::BENCH, "    - Verify %u txins: %.2fms (%.3fms/txin) [%.2fs (%.2fms/blk)]\n", nInputs - 1,
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    2435                 :            :              Ticks<MillisecondsDouble>(time_4 - time_2),
    2436                 :            :              nInputs <= 1 ? 0 : Ticks<MillisecondsDouble>(time_4 - time_2) / (nInputs - 1),
    2437                 :            :              Ticks<SecondsDouble>(time_verify),
    2438                 :            :              Ticks<MillisecondsDouble>(time_verify) / num_blocks_total);
    2439                 :            : 
    2440         [ #  # ]:          0 :     if (fJustCheck)
    2441                 :          0 :         return true;
    2442                 :            : 
    2443   [ #  #  #  # ]:          0 :     if (!m_blockman.WriteUndoDataForBlock(blockundo, state, *pindex)) {
    2444                 :          0 :         return false;
    2445                 :            :     }
    2446                 :            : 
    2447                 :          0 :     const auto time_5{SteadyClock::now()};
    2448   [ #  #  #  # ]:          0 :     time_undo += time_5 - time_4;
    2449   [ #  #  #  #  :          0 :     LogPrint(BCLog::BENCH, "    - Write undo data: %.2fms [%.2fs (%.2fms/blk)]\n",
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
    2450                 :            :              Ticks<MillisecondsDouble>(time_5 - time_4),
    2451                 :            :              Ticks<SecondsDouble>(time_undo),
    2452                 :            :              Ticks<MillisecondsDouble>(time_undo) / num_blocks_total);
    2453                 :            : 
    2454   [ #  #  #  # ]:          0 :     if (!pindex->IsValid(BLOCK_VALID_SCRIPTS)) {
    2455         [ #  # ]:          0 :         pindex->RaiseValidity(BLOCK_VALID_SCRIPTS);
    2456         [ #  # ]:          0 :         m_blockman.m_dirty_blockindex.insert(pindex);
    2457                 :          0 :     }
    2458                 :            : 
    2459                 :            :     // add this block to the view's block chain
    2460   [ #  #  #  # ]:          0 :     view.SetBestBlock(pindex->GetBlockHash());
    2461                 :            : 
    2462                 :          0 :     const auto time_6{SteadyClock::now()};
    2463   [ #  #  #  # ]:          0 :     time_index += time_6 - time_5;
    2464   [ #  #  #  #  :          0 :     LogPrint(BCLog::BENCH, "    - Index writing: %.2fms [%.2fs (%.2fms/blk)]\n",
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
    2465                 :            :              Ticks<MillisecondsDouble>(time_6 - time_5),
    2466                 :            :              Ticks<SecondsDouble>(time_index),
    2467                 :            :              Ticks<MillisecondsDouble>(time_index) / num_blocks_total);
    2468                 :            : 
    2469                 :            :     TRACE6(validation, block_connected,
    2470                 :            :         block_hash.data(),
    2471                 :            :         pindex->nHeight,
    2472                 :            :         block.vtx.size(),
    2473                 :            :         nInputs,
    2474                 :            :         nSigOpsCost,
    2475                 :            :         time_5 - time_start // in microseconds (µs)
    2476                 :            :     );
    2477                 :            : 
    2478                 :          0 :     return true;
    2479                 :          1 : }
    2480                 :            : 
    2481                 :          3 : CoinsCacheSizeState Chainstate::GetCoinsCacheSizeState()
    2482                 :            : {
    2483                 :          3 :     AssertLockHeld(::cs_main);
    2484                 :          3 :     return this->GetCoinsCacheSizeState(
    2485                 :          3 :         m_coinstip_cache_size_bytes,
    2486         [ +  - ]:          3 :         m_mempool ? m_mempool->m_max_size_bytes : 0);
    2487                 :            : }
    2488                 :            : 
    2489                 :          3 : CoinsCacheSizeState Chainstate::GetCoinsCacheSizeState(
    2490                 :            :     size_t max_coins_cache_size_bytes,
    2491                 :            :     size_t max_mempool_size_bytes)
    2492                 :            : {
    2493                 :          3 :     AssertLockHeld(::cs_main);
    2494         [ +  - ]:          3 :     const int64_t nMempoolUsage = m_mempool ? m_mempool->DynamicMemoryUsage() : 0;
    2495                 :          3 :     int64_t cacheSize = CoinsTip().DynamicMemoryUsage();
    2496                 :          3 :     int64_t nTotalSpace =
    2497                 :          3 :         max_coins_cache_size_bytes + std::max<int64_t>(int64_t(max_mempool_size_bytes) - nMempoolUsage, 0);
    2498                 :            : 
    2499                 :            :     //! No need to periodic flush if at least this much space still available.
    2500                 :            :     static constexpr int64_t MAX_BLOCK_COINSDB_USAGE_BYTES = 10 * 1024 * 1024;  // 10MB
    2501                 :          3 :     int64_t large_threshold =
    2502                 :          3 :         std::max((9 * nTotalSpace) / 10, nTotalSpace - MAX_BLOCK_COINSDB_USAGE_BYTES);
    2503                 :            : 
    2504         [ -  + ]:          3 :     if (cacheSize > nTotalSpace) {
    2505   [ #  #  #  #  :          0 :         LogPrintf("Cache size (%s) exceeds total space (%s)\n", cacheSize, nTotalSpace);
                   #  # ]
    2506                 :          0 :         return CoinsCacheSizeState::CRITICAL;
    2507         [ -  + ]:          3 :     } else if (cacheSize > large_threshold) {
    2508                 :          0 :         return CoinsCacheSizeState::LARGE;
    2509                 :            :     }
    2510                 :          3 :     return CoinsCacheSizeState::OK;
    2511                 :          3 : }
    2512                 :            : 
    2513                 :          3 : bool Chainstate::FlushStateToDisk(
    2514                 :            :     BlockValidationState &state,
    2515                 :            :     FlushStateMode mode,
    2516                 :            :     int nManualPruneHeight)
    2517                 :            : {
    2518                 :          3 :     LOCK(cs_main);
    2519   [ +  -  +  - ]:          3 :     assert(this->CanFlushToDisk());
    2520                 :          3 :     std::set<int> setFilesToPrune;
    2521                 :          3 :     bool full_flush_completed = false;
    2522                 :            : 
    2523   [ +  -  +  - ]:          3 :     const size_t coins_count = CoinsTip().GetCacheSize();
    2524   [ +  -  +  - ]:          3 :     const size_t coins_mem_usage = CoinsTip().DynamicMemoryUsage();
    2525                 :            : 
    2526                 :            :     try {
    2527                 :            :     {
    2528                 :          3 :         bool fFlushForPrune = false;
    2529                 :          3 :         bool fDoFullFlush = false;
    2530                 :            : 
    2531         [ +  - ]:          3 :         CoinsCacheSizeState cache_state = GetCoinsCacheSizeState();
    2532   [ +  -  +  - ]:          3 :         LOCK(m_blockman.cs_LastBlockFile);
    2533   [ +  -  -  +  :          3 :         if (m_blockman.IsPruneMode() && (m_blockman.m_check_for_pruning || nManualPruneHeight > 0) && !fReindex) {
             #  #  #  # ]
    2534                 :            :             // make sure we don't prune above any of the prune locks bestblocks
    2535                 :            :             // pruning is height-based
    2536         [ #  # ]:          0 :             int last_prune{m_chain.Height()}; // last height we can prune
    2537                 :          0 :             std::optional<std::string> limiting_lock; // prune lock that actually was the limiting factor, only used for logging
    2538                 :            : 
    2539         [ #  # ]:          0 :             for (const auto& prune_lock : m_blockman.m_prune_locks) {
    2540         [ #  # ]:          0 :                 if (prune_lock.second.height_first == std::numeric_limits<int>::max()) continue;
    2541                 :            :                 // Remove the buffer and one additional block here to get actual height that is outside of the buffer
    2542                 :          0 :                 const int lock_height{prune_lock.second.height_first - PRUNE_LOCK_BUFFER - 1};
    2543   [ #  #  #  # ]:          0 :                 last_prune = std::max(1, std::min(last_prune, lock_height));
    2544         [ #  # ]:          0 :                 if (last_prune == lock_height) {
    2545         [ #  # ]:          0 :                     limiting_lock = prune_lock.first;
    2546                 :          0 :                 }
    2547                 :            :             }
    2548                 :            : 
    2549         [ #  # ]:          0 :             if (limiting_lock) {
    2550   [ #  #  #  #  :          0 :                 LogPrint(BCLog::PRUNE, "%s limited pruning to height %d\n", limiting_lock.value(), last_prune);
          #  #  #  #  #  
                #  #  # ]
    2551                 :          0 :             }
    2552                 :            : 
    2553         [ #  # ]:          0 :             if (nManualPruneHeight > 0) {
    2554   [ #  #  #  #  :          0 :                 LOG_TIME_MILLIS_WITH_CATEGORY("find files to prune (manual)", BCLog::BENCH);
                   #  # ]
    2555                 :            : 
    2556         [ #  # ]:          0 :                 m_blockman.FindFilesToPruneManual(
    2557                 :            :                     setFilesToPrune,
    2558         [ #  # ]:          0 :                     std::min(last_prune, nManualPruneHeight),
    2559                 :          0 :                     *this, m_chainman);
    2560                 :          0 :             } else {
    2561   [ #  #  #  #  :          0 :                 LOG_TIME_MILLIS_WITH_CATEGORY("find files to prune", BCLog::BENCH);
                   #  # ]
    2562                 :            : 
    2563         [ #  # ]:          0 :                 m_blockman.FindFilesToPrune(setFilesToPrune, last_prune, *this, m_chainman);
    2564                 :          0 :                 m_blockman.m_check_for_pruning = false;
    2565                 :          0 :             }
    2566         [ #  # ]:          0 :             if (!setFilesToPrune.empty()) {
    2567                 :          0 :                 fFlushForPrune = true;
    2568         [ #  # ]:          0 :                 if (!m_blockman.m_have_pruned) {
    2569   [ #  #  #  # ]:          0 :                     m_blockman.m_block_tree_db->WriteFlag("prunedblockfiles", true);
    2570                 :          0 :                     m_blockman.m_have_pruned = true;
    2571                 :          0 :                 }
    2572                 :          0 :             }
    2573                 :          0 :         }
    2574                 :          3 :         const auto nNow{SteadyClock::now()};
    2575                 :            :         // Avoid writing/flushing immediately after startup.
    2576   [ +  -  +  -  :          3 :         if (m_last_write == decltype(m_last_write){}) {
                   +  + ]
    2577                 :          1 :             m_last_write = nNow;
    2578                 :          1 :         }
    2579   [ +  -  +  -  :          3 :         if (m_last_flush == decltype(m_last_flush){}) {
                   +  + ]
    2580                 :          1 :             m_last_flush = nNow;
    2581                 :          1 :         }
    2582                 :            :         // The cache is large and we're within 10% and 10 MiB of the limit, but we have time now (not in the middle of a block processing).
    2583         [ +  + ]:          3 :         bool fCacheLarge = mode == FlushStateMode::PERIODIC && cache_state >= CoinsCacheSizeState::LARGE;
    2584                 :            :         // The cache is over the limit, we have to write now.
    2585         [ +  + ]:          3 :         bool fCacheCritical = mode == FlushStateMode::IF_NEEDED && cache_state >= CoinsCacheSizeState::CRITICAL;
    2586                 :            :         // It's been a while since we wrote the block index to disk. Do this frequently, so we don't need to redownload after a crash.
    2587   [ +  +  +  -  :          4 :         bool fPeriodicWrite = mode == FlushStateMode::PERIODIC && nNow > m_last_write + DATABASE_WRITE_INTERVAL;
                   +  - ]
    2588                 :            :         // It's been very long since we flushed the cache. Do this infrequently, to optimize cache usage.
    2589   [ +  +  +  -  :          4 :         bool fPeriodicFlush = mode == FlushStateMode::PERIODIC && nNow > m_last_flush + DATABASE_FLUSH_INTERVAL;
                   +  - ]
    2590                 :            :         // Combine all conditions that result in a full cache flush.
    2591   [ +  -  +  -  :          3 :         fDoFullFlush = (mode == FlushStateMode::ALWAYS) || fCacheLarge || fCacheCritical || fPeriodicFlush || fFlushForPrune;
             +  -  -  + ]
    2592                 :            :         // Write blocks and block index to disk.
    2593   [ +  -  -  + ]:          3 :         if (fDoFullFlush || fPeriodicWrite) {
    2594                 :            :             // Ensure we can write block index
    2595   [ #  #  #  # ]:          0 :             if (!CheckDiskSpace(m_blockman.m_opts.blocks_dir)) {
    2596   [ #  #  #  #  :          0 :                 return FatalError(m_chainman.GetNotifications(), state, "Disk space is too low!", _("Disk space is too low!"));
             #  #  #  # ]
    2597                 :            :             }
    2598                 :            :             {
    2599   [ #  #  #  #  :          0 :                 LOG_TIME_MILLIS_WITH_CATEGORY("write block and undo data to disk", BCLog::BENCH);
                   #  # ]
    2600                 :            : 
    2601                 :            :                 // First make sure all block and undo data is flushed to disk.
    2602                 :            :                 // TODO: Handle return error, or add detailed comment why it is
    2603                 :            :                 // safe to not return an error upon failure.
    2604   [ #  #  #  #  :          0 :                 if (!m_blockman.FlushChainstateBlockFile(m_chain.Height())) {
                   #  # ]
    2605   [ #  #  #  #  :          0 :                     LogPrintLevel(BCLog::VALIDATION, BCLog::Level::Warning, "%s: Failed to flush block file.\n", __func__);
          #  #  #  #  #  
                      # ]
    2606                 :          0 :                 }
    2607                 :          0 :             }
    2608                 :            : 
    2609                 :            :             // Then update all block file information (which may refer to block and undo files).
    2610                 :            :             {
    2611   [ #  #  #  #  :          0 :                 LOG_TIME_MILLIS_WITH_CATEGORY("write block index to disk", BCLog::BENCH);
                   #  # ]
    2612                 :            : 
    2613   [ #  #  #  # ]:          0 :                 if (!m_blockman.WriteBlockIndexDB()) {
    2614   [ #  #  #  #  :          0 :                     return FatalError(m_chainman.GetNotifications(), state, "Failed to write to block index database");
                   #  # ]
    2615                 :            :                 }
    2616         [ #  # ]:          0 :             }
    2617                 :            :             // Finally remove any pruned files
    2618         [ #  # ]:          0 :             if (fFlushForPrune) {
    2619   [ #  #  #  #  :          0 :                 LOG_TIME_MILLIS_WITH_CATEGORY("unlink pruned files", BCLog::BENCH);
                   #  # ]
    2620                 :            : 
    2621         [ #  # ]:          0 :                 m_blockman.UnlinkPrunedFiles(setFilesToPrune);
    2622                 :          0 :             }
    2623                 :          0 :             m_last_write = nNow;
    2624                 :          0 :         }
    2625                 :            :         // Flush best chain related state. This can only be done if the blocks / block index write was also done.
    2626   [ -  +  #  #  :          3 :         if (fDoFullFlush && !CoinsTip().GetBestBlock().IsNull()) {
          #  #  #  #  +  
                      - ]
    2627   [ #  #  #  #  :          0 :             LOG_TIME_MILLIS_WITH_CATEGORY(strprintf("write coins cache to disk (%d coins, %.2fkB)",
                   #  # ]
    2628                 :            :                 coins_count, coins_mem_usage / 1000), BCLog::BENCH);
    2629                 :            : 
    2630                 :            :             // Typical Coin structures on disk are around 48 bytes in size.
    2631                 :            :             // Pushing a new one to the database can cause it to be written
    2632                 :            :             // twice (once in the log, and once in the tables). This is already
    2633                 :            :             // an overestimation, as most will delete an existing entry or
    2634                 :            :             // overwrite one. Still, use a conservative safety factor of 2.
    2635   [ #  #  #  #  :          0 :             if (!CheckDiskSpace(m_chainman.m_options.datadir, 48 * 2 * 2 * CoinsTip().GetCacheSize())) {
             #  #  #  # ]
    2636   [ #  #  #  #  :          0 :                 return FatalError(m_chainman.GetNotifications(), state, "Disk space is too low!", _("Disk space is too low!"));
             #  #  #  # ]
    2637                 :            :             }
    2638                 :            :             // Flush the chainstate (which may refer to block index entries).
    2639   [ #  #  #  #  :          0 :             if (!CoinsTip().Flush())
                   #  # ]
    2640   [ #  #  #  #  :          0 :                 return FatalError(m_chainman.GetNotifications(), state, "Failed to write to coin database");
                   #  # ]
    2641                 :          0 :             m_last_flush = nNow;
    2642                 :          0 :             full_flush_completed = true;
    2643                 :            :             TRACE5(utxocache, flush,
    2644                 :            :                    int64_t{Ticks<std::chrono::microseconds>(SteadyClock::now() - nNow)},
    2645                 :            :                    (uint32_t)mode,
    2646                 :            :                    (uint64_t)coins_count,
    2647                 :            :                    (uint64_t)coins_mem_usage,
    2648                 :            :                    (bool)fFlushForPrune);
    2649         [ #  # ]:          0 :         }
    2650         [ -  + ]:          3 :     }
    2651         [ -  + ]:          3 :     if (full_flush_completed) {
    2652                 :            :         // Update best block in wallet (so we can detect restored wallets).
    2653   [ #  #  #  #  :          0 :         GetMainSignals().ChainStateFlushed(this->GetRole(), m_chain.GetLocator());
             #  #  #  # ]
    2654                 :          0 :     }
    2655         [ #  # ]:          3 :     } catch (const std::runtime_error& e) {
    2656   [ #  #  #  #  :          0 :         return FatalError(m_chainman.GetNotifications(), state, std::string("System error while flushing: ") + e.what());
             #  #  #  # ]
    2657   [ #  #  #  # ]:          0 :     }
    2658                 :          3 :     return true;
    2659                 :          3 : }
    2660                 :            : 
    2661                 :          0 : void Chainstate::ForceFlushStateToDisk()
    2662                 :            : {
    2663                 :          0 :     BlockValidationState state;
    2664   [ #  #  #  # ]:          0 :     if (!this->FlushStateToDisk(state, FlushStateMode::ALWAYS)) {
    2665   [ #  #  #  #  :          0 :         LogPrintf("%s: failed to flush state (%s)\n", __func__, state.ToString());
             #  #  #  # ]
    2666                 :          0 :     }
    2667                 :          0 : }
    2668                 :            : 
    2669                 :          0 : void Chainstate::PruneAndFlush()
    2670                 :            : {
    2671                 :          0 :     BlockValidationState state;
    2672                 :          0 :     m_blockman.m_check_for_pruning = true;
    2673   [ #  #  #  # ]:          0 :     if (!this->FlushStateToDisk(state, FlushStateMode::NONE)) {
    2674   [ #  #  #  #  :          0 :         LogPrintf("%s: failed to flush state (%s)\n", __func__, state.ToString());
             #  #  #  # ]
    2675                 :          0 :     }
    2676                 :          0 : }
    2677                 :            : 
    2678                 :            : /** Private helper function that concatenates warning messages. */
    2679                 :          0 : static void AppendWarning(bilingual_str& res, const bilingual_str& warn)
    2680                 :            : {
    2681   [ #  #  #  #  :          0 :     if (!res.empty()) res += Untranslated(", ");
             #  #  #  # ]
    2682                 :          0 :     res += warn;
    2683                 :          0 : }
    2684                 :            : 
    2685                 :          1 : static void UpdateTipLog(
    2686                 :            :     const CCoinsViewCache& coins_tip,
    2687                 :            :     const CBlockIndex* tip,
    2688                 :            :     const CChainParams& params,
    2689                 :            :     const std::string& func_name,
    2690                 :            :     const std::string& prefix,
    2691                 :            :     const std::string& warning_messages) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
    2692                 :            : {
    2693                 :            : 
    2694                 :          1 :     AssertLockHeld(::cs_main);
    2695   [ +  -  +  -  :          1 :     LogPrintf("%s%s: new best=%s height=%d version=0x%08x log2_work=%f tx=%lu date='%s' progress=%f cache=%.1fMiB(%utxo)%s\n",
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  -  
          +  #  #  -  +  
          +  -  -  +  #  
                      # ]
    2696                 :            :         prefix, func_name,
    2697                 :            :         tip->GetBlockHash().ToString(), tip->nHeight, tip->nVersion,
    2698                 :            :         log(tip->nChainWork.getdouble()) / log(2.0), (unsigned long)tip->nChainTx,
    2699                 :            :         FormatISO8601DateTime(tip->GetBlockTime()),
    2700                 :            :         GuessVerificationProgress(params.TxData(), tip),
    2701                 :            :         coins_tip.DynamicMemoryUsage() * (1.0 / (1 << 20)),
    2702                 :            :         coins_tip.GetCacheSize(),
    2703                 :            :         !warning_messages.empty() ? strprintf(" warning='%s'", warning_messages) : "");
    2704                 :          1 : }
    2705                 :            : 
    2706                 :          1 : void Chainstate::UpdateTip(const CBlockIndex* pindexNew)
    2707                 :            : {
    2708                 :          1 :     AssertLockHeld(::cs_main);
    2709                 :          1 :     const auto& coins_tip = this->CoinsTip();
    2710                 :            : 
    2711                 :          1 :     const CChainParams& params{m_chainman.GetParams()};
    2712                 :            : 
    2713                 :            :     // The remainder of the function isn't relevant if we are not acting on
    2714                 :            :     // the active chainstate, so return if need be.
    2715         [ -  + ]:          1 :     if (this != &m_chainman.ActiveChainstate()) {
    2716                 :            :         // Only log every so often so that we don't bury log messages at the tip.
    2717                 :          0 :         constexpr int BACKGROUND_LOG_INTERVAL = 2000;
    2718         [ #  # ]:          0 :         if (pindexNew->nHeight % BACKGROUND_LOG_INTERVAL == 0) {
    2719   [ #  #  #  #  :          0 :             UpdateTipLog(coins_tip, pindexNew, params, __func__, "[background validation] ", "");
             #  #  #  # ]
    2720                 :          0 :         }
    2721                 :          0 :         return;
    2722                 :            :     }
    2723                 :            : 
    2724                 :            :     // New best block
    2725         [ +  - ]:          1 :     if (m_mempool) {
    2726                 :          1 :         m_mempool->AddTransactionsUpdated(1);
    2727                 :          1 :     }
    2728                 :            : 
    2729                 :            :     {
    2730                 :          1 :         LOCK(g_best_block_mutex);
    2731         [ +  - ]:          1 :         g_best_block = pindexNew->GetBlockHash();
    2732                 :          1 :         g_best_block_cv.notify_all();
    2733                 :          1 :     }
    2734                 :            : 
    2735                 :          1 :     bilingual_str warning_messages;
    2736   [ +  -  +  - ]:          1 :     if (!m_chainman.IsInitialBlockDownload()) {
    2737                 :          0 :         const CBlockIndex* pindex = pindexNew;
    2738         [ #  # ]:          0 :         for (int bit = 0; bit < VERSIONBITS_NUM_BITS; bit++) {
    2739         [ #  # ]:          0 :             WarningBitsConditionChecker checker(m_chainman, bit);
    2740   [ #  #  #  #  :          0 :             ThresholdState state = checker.GetStateFor(pindex, params.GetConsensus(), m_chainman.m_warningcache.at(bit));
                   #  # ]
    2741   [ #  #  #  # ]:          0 :             if (state == ThresholdState::ACTIVE || state == ThresholdState::LOCKED_IN) {
    2742   [ #  #  #  # ]:          0 :                 const bilingual_str warning = strprintf(_("Unknown new rules activated (versionbit %i)"), bit);
    2743         [ #  # ]:          0 :                 if (state == ThresholdState::ACTIVE) {
    2744   [ #  #  #  # ]:          0 :                     m_chainman.GetNotifications().warning(warning);
    2745                 :          0 :                 } else {
    2746         [ #  # ]:          0 :                     AppendWarning(warning_messages, warning);
    2747                 :            :                 }
    2748                 :          0 :             }
    2749                 :          0 :         }
    2750                 :          0 :     }
    2751   [ +  -  +  -  :          1 :     UpdateTipLog(coins_tip, pindexNew, params, __func__, "", warning_messages.original);
                   +  - ]
    2752                 :          1 : }
    2753                 :            : 
    2754                 :            : /** Disconnect m_chain's tip.
    2755                 :            :   * After calling, the mempool will be in an inconsistent state, with
    2756                 :            :   * transactions from disconnected blocks being added to disconnectpool.  You
    2757                 :            :   * should make the mempool consistent again by calling MaybeUpdateMempoolForReorg.
    2758                 :            :   * with cs_main held.
    2759                 :            :   *
    2760                 :            :   * If disconnectpool is nullptr, then no disconnected transactions are added to
    2761                 :            :   * disconnectpool (note that the caller is responsible for mempool consistency
    2762                 :            :   * in any case).
    2763                 :            :   */
    2764                 :          0 : bool Chainstate::DisconnectTip(BlockValidationState& state, DisconnectedBlockTransactions* disconnectpool)
    2765                 :            : {
    2766                 :          0 :     AssertLockHeld(cs_main);
    2767         [ #  # ]:          0 :     if (m_mempool) AssertLockHeld(m_mempool->cs);
    2768                 :            : 
    2769                 :          0 :     CBlockIndex *pindexDelete = m_chain.Tip();
    2770         [ #  # ]:          0 :     assert(pindexDelete);
    2771         [ #  # ]:          0 :     assert(pindexDelete->pprev);
    2772                 :            :     // Read block from disk.
    2773                 :          0 :     std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
    2774                 :          0 :     CBlock& block = *pblock;
    2775   [ #  #  #  # ]:          0 :     if (!m_blockman.ReadBlockFromDisk(block, *pindexDelete)) {
    2776         [ #  # ]:          0 :         return error("DisconnectTip(): Failed to read block");
    2777                 :            :     }
    2778                 :            :     // Apply the block atomically to the chain state.
    2779                 :          0 :     const auto time_start{SteadyClock::now()};
    2780                 :            :     {
    2781   [ #  #  #  # ]:          0 :         CCoinsViewCache view(&CoinsTip());
    2782   [ #  #  #  #  :          0 :         assert(view.GetBestBlock() == pindexDelete->GetBlockHash());
             #  #  #  # ]
    2783   [ #  #  #  # ]:          0 :         if (DisconnectBlock(block, pindexDelete, view) != DISCONNECT_OK)
    2784   [ #  #  #  #  :          0 :             return error("DisconnectTip(): DisconnectBlock %s failed", pindexDelete->GetBlockHash().ToString());
                   #  # ]
    2785         [ #  # ]:          0 :         bool flushed = view.Flush();
    2786         [ #  # ]:          0 :         assert(flushed);
    2787         [ #  # ]:          0 :     }
    2788   [ #  #  #  #  :          0 :     LogPrint(BCLog::BENCH, "- Disconnect block: %.2fms\n",
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    2789                 :            :              Ticks<MillisecondsDouble>(SteadyClock::now() - time_start));
    2790                 :            : 
    2791                 :            :     {
    2792                 :            :         // Prune locks that began at or after the tip should be moved backward so they get a chance to reorg
    2793                 :          0 :         const int max_height_first{pindexDelete->nHeight - 1};
    2794         [ #  # ]:          0 :         for (auto& prune_lock : m_blockman.m_prune_locks) {
    2795         [ #  # ]:          0 :             if (prune_lock.second.height_first <= max_height_first) continue;
    2796                 :            : 
    2797                 :          0 :             prune_lock.second.height_first = max_height_first;
    2798   [ #  #  #  #  :          0 :             LogPrint(BCLog::PRUNE, "%s prune lock moved back to %d\n", prune_lock.first, max_height_first);
          #  #  #  #  #  
                      # ]
    2799                 :            :         }
    2800                 :            :     }
    2801                 :            : 
    2802                 :            :     // Write the chain state to disk, if necessary.
    2803   [ #  #  #  # ]:          0 :     if (!FlushStateToDisk(state, FlushStateMode::IF_NEEDED)) {
    2804                 :          0 :         return false;
    2805                 :            :     }
    2806                 :            : 
    2807   [ #  #  #  # ]:          0 :     if (disconnectpool && m_mempool) {
    2808                 :            :         // Save transactions to re-add to mempool at end of reorg. If any entries are evicted for
    2809                 :            :         // exceeding memory limits, remove them and their descendants from the mempool.
    2810   [ #  #  #  # ]:          0 :         for (auto&& evicted_tx : disconnectpool->AddTransactionsFromBlock(block.vtx)) {
    2811         [ #  # ]:          0 :             m_mempool->removeRecursive(*evicted_tx, MemPoolRemovalReason::REORG);
    2812                 :            :         }
    2813                 :          0 :     }
    2814                 :            : 
    2815         [ #  # ]:          0 :     m_chain.SetTip(*pindexDelete->pprev);
    2816                 :            : 
    2817         [ #  # ]:          0 :     UpdateTip(pindexDelete->pprev);
    2818                 :            :     // Let wallets know transactions went from 1-confirmed to
    2819                 :            :     // 0-confirmed or conflicted:
    2820   [ #  #  #  # ]:          0 :     GetMainSignals().BlockDisconnected(pblock, pindexDelete);
    2821                 :          0 :     return true;
    2822                 :          0 : }
    2823                 :            : 
    2824                 :            : static SteadyClock::duration time_connect_total{};
    2825                 :            : static SteadyClock::duration time_flush{};
    2826                 :            : static SteadyClock::duration time_chainstate{};
    2827                 :            : static SteadyClock::duration time_post_connect{};
    2828                 :            : 
    2829                 :            : struct PerBlockConnectTrace {
    2830                 :          2 :     CBlockIndex* pindex = nullptr;
    2831                 :            :     std::shared_ptr<const CBlock> pblock;
    2832                 :          4 :     PerBlockConnectTrace() = default;
    2833                 :            : };
    2834                 :            : /**
    2835                 :            :  * Used to track blocks whose transactions were applied to the UTXO state as a
    2836                 :            :  * part of a single ActivateBestChainStep call.
    2837                 :            :  *
    2838                 :            :  * This class is single-use, once you call GetBlocksConnected() you have to throw
    2839                 :            :  * it away and make a new one.
    2840                 :            :  */
    2841                 :            : class ConnectTrace {
    2842                 :            : private:
    2843                 :            :     std::vector<PerBlockConnectTrace> blocksConnected;
    2844                 :            : 
    2845                 :            : public:
    2846         [ +  - ]:          1 :     explicit ConnectTrace() : blocksConnected(1) {}
    2847                 :            : 
    2848                 :          1 :     void BlockConnected(CBlockIndex* pindex, std::shared_ptr<const CBlock> pblock) {
    2849         [ +  - ]:          1 :         assert(!blocksConnected.back().pindex);
    2850         [ +  - ]:          1 :         assert(pindex);
    2851         [ +  - ]:          1 :         assert(pblock);
    2852                 :          1 :         blocksConnected.back().pindex = pindex;
    2853                 :          1 :         blocksConnected.back().pblock = std::move(pblock);
    2854                 :          1 :         blocksConnected.emplace_back();
    2855                 :          1 :     }
    2856                 :            : 
    2857                 :          1 :     std::vector<PerBlockConnectTrace>& GetBlocksConnected() {
    2858                 :            :         // We always keep one extra block at the end of our list because
    2859                 :            :         // blocks are added after all the conflicted transactions have
    2860                 :            :         // been filled in. Thus, the last entry should always be an empty
    2861                 :            :         // one waiting for the transactions from the next block. We pop
    2862                 :            :         // the last entry here to make sure the list we return is sane.
    2863         [ +  - ]:          1 :         assert(!blocksConnected.back().pindex);
    2864                 :          1 :         blocksConnected.pop_back();
    2865                 :          1 :         return blocksConnected;
    2866                 :            :     }
    2867                 :            : };
    2868                 :            : 
    2869                 :            : /**
    2870                 :            :  * Connect a new block to m_chain. pblock is either nullptr or a pointer to a CBlock
    2871                 :            :  * corresponding to pindexNew, to bypass loading it again from disk.
    2872                 :            :  *
    2873                 :            :  * The block is added to connectTrace if connection succeeds.
    2874                 :            :  */
    2875                 :          1 : bool Chainstate::ConnectTip(BlockValidationState& state, CBlockIndex* pindexNew, const std::shared_ptr<const CBlock>& pblock, ConnectTrace& connectTrace, DisconnectedBlockTransactions& disconnectpool)
    2876                 :            : {
    2877                 :          1 :     AssertLockHeld(cs_main);
    2878         [ -  + ]:          1 :     if (m_mempool) AssertLockHeld(m_mempool->cs);
    2879                 :            : 
    2880         [ +  - ]:          1 :     assert(pindexNew->pprev == m_chain.Tip());
    2881                 :            :     // Read block from disk.
    2882                 :          1 :     const auto time_1{SteadyClock::now()};
    2883                 :          1 :     std::shared_ptr<const CBlock> pthisBlock;
    2884   [ +  -  +  - ]:          1 :     if (!pblock) {
    2885         [ +  - ]:          1 :         std::shared_ptr<CBlock> pblockNew = std::make_shared<CBlock>();
    2886   [ +  -  -  + ]:          1 :         if (!m_blockman.ReadBlockFromDisk(*pblockNew, *pindexNew)) {
    2887   [ #  #  #  #  :          0 :             return FatalError(m_chainman.GetNotifications(), state, "Failed to read block");
                   #  # ]
    2888                 :            :         }
    2889                 :          1 :         pthisBlock = pblockNew;
    2890         [ -  + ]:          1 :     } else {
    2891   [ #  #  #  #  :          0 :         LogPrint(BCLog::BENCH, "  - Using cached block\n");
          #  #  #  #  #  
                      # ]
    2892                 :          0 :         pthisBlock = pblock;
    2893                 :            :     }
    2894                 :          1 :     const CBlock& blockConnecting = *pthisBlock;
    2895                 :            :     // Apply the block atomically to the chain state.
    2896                 :          1 :     const auto time_2{SteadyClock::now()};
    2897         [ +  - ]:          1 :     SteadyClock::time_point time_3;
    2898                 :            :     // When adding aggregate statistics in the future, keep in mind that
    2899                 :            :     // num_blocks_total may be zero until the ConnectBlock() call below.
    2900   [ +  -  +  -  :          1 :     LogPrint(BCLog::BENCH, "  - Load block from disk: %.2fms\n",
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    2901                 :            :              Ticks<MillisecondsDouble>(time_2 - time_1));
    2902                 :            :     {
    2903   [ +  -  +  - ]:          1 :         CCoinsViewCache view(&CoinsTip());
    2904         [ +  - ]:          1 :         bool rv = ConnectBlock(blockConnecting, state, pindexNew, view);
    2905   [ +  -  +  - ]:          1 :         GetMainSignals().BlockChecked(blockConnecting, state);
    2906         [ -  + ]:          1 :         if (!rv) {
    2907   [ #  #  #  # ]:          0 :             if (state.IsInvalid())
    2908         [ #  # ]:          0 :                 InvalidBlockFound(pindexNew, state);
    2909   [ #  #  #  #  :          0 :             return error("%s: ConnectBlock %s failed, %s", __func__, pindexNew->GetBlockHash().ToString(), state.ToString());
             #  #  #  # ]
    2910                 :            :         }
    2911                 :          1 :         time_3 = SteadyClock::now();
    2912   [ +  -  +  - ]:          1 :         time_connect_total += time_3 - time_2;
    2913         [ +  - ]:          1 :         assert(num_blocks_total > 0);
    2914   [ +  -  +  -  :          1 :         LogPrint(BCLog::BENCH, "  - Connect total: %.2fms [%.2fs (%.2fms/blk)]\n",
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
    2915                 :            :                  Ticks<MillisecondsDouble>(time_3 - time_2),
    2916                 :            :                  Ticks<SecondsDouble>(time_connect_total),
    2917                 :            :                  Ticks<MillisecondsDouble>(time_connect_total) / num_blocks_total);
    2918         [ +  - ]:          1 :         bool flushed = view.Flush();
    2919         [ +  - ]:          1 :         assert(flushed);
    2920         [ +  - ]:          1 :     }
    2921                 :          1 :     const auto time_4{SteadyClock::now()};
    2922   [ +  -  +  - ]:          1 :     time_flush += time_4 - time_3;
    2923   [ +  -  +  -  :          1 :     LogPrint(BCLog::BENCH, "  - Flush: %.2fms [%.2fs (%.2fms/blk)]\n",
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
    2924                 :            :              Ticks<MillisecondsDouble>(time_4 - time_3),
    2925                 :            :              Ticks<SecondsDouble>(time_flush),
    2926                 :            :              Ticks<MillisecondsDouble>(time_flush) / num_blocks_total);
    2927                 :            :     // Write the chain state to disk, if necessary.
    2928   [ +  -  +  - ]:          1 :     if (!FlushStateToDisk(state, FlushStateMode::IF_NEEDED)) {
    2929                 :          0 :         return false;
    2930                 :            :     }
    2931                 :          1 :     const auto time_5{SteadyClock::now()};
    2932   [ +  -  +  - ]:          1 :     time_chainstate += time_5 - time_4;
    2933   [ +  -  +  -  :          1 :     LogPrint(BCLog::BENCH, "  - Writing chainstate: %.2fms [%.2fs (%.2fms/blk)]\n",
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
    2934                 :            :              Ticks<MillisecondsDouble>(time_5 - time_4),
    2935                 :            :              Ticks<SecondsDouble>(time_chainstate),
    2936                 :            :              Ticks<MillisecondsDouble>(time_chainstate) / num_blocks_total);
    2937                 :            :     // Remove conflicting transactions from the mempool.;
    2938         [ +  - ]:          1 :     if (m_mempool) {
    2939         [ +  - ]:          1 :         m_mempool->removeForBlock(blockConnecting.vtx, pindexNew->nHeight);
    2940         [ +  - ]:          1 :         disconnectpool.removeForBlock(blockConnecting.vtx);
    2941                 :          1 :     }
    2942                 :            :     // Update m_chain & related variables.
    2943         [ +  - ]:          1 :     m_chain.SetTip(*pindexNew);
    2944         [ +  - ]:          1 :     UpdateTip(pindexNew);
    2945                 :            : 
    2946                 :          1 :     const auto time_6{SteadyClock::now()};
    2947   [ +  -  +  - ]:          1 :     time_post_connect += time_6 - time_5;
    2948   [ +  -  +  - ]:          1 :     time_total += time_6 - time_1;
    2949   [ +  -  +  -  :          1 :     LogPrint(BCLog::BENCH, "  - Connect postprocess: %.2fms [%.2fs (%.2fms/blk)]\n",
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
    2950                 :            :              Ticks<MillisecondsDouble>(time_6 - time_5),
    2951                 :            :              Ticks<SecondsDouble>(time_post_connect),
    2952                 :            :              Ticks<MillisecondsDouble>(time_post_connect) / num_blocks_total);
    2953   [ +  -  +  -  :          1 :     LogPrint(BCLog::BENCH, "- Connect block: %.2fms [%.2fs (%.2fms/blk)]\n",
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
    2954                 :            :              Ticks<MillisecondsDouble>(time_6 - time_1),
    2955                 :            :              Ticks<SecondsDouble>(time_total),
    2956                 :            :              Ticks<MillisecondsDouble>(time_total) / num_blocks_total);
    2957                 :            : 
    2958                 :            :     // If we are the background validation chainstate, check to see if we are done
    2959                 :            :     // validating the snapshot (i.e. our tip has reached the snapshot's base block).
    2960   [ +  -  -  + ]:          1 :     if (this != &m_chainman.ActiveChainstate()) {
    2961                 :            :         // This call may set `m_disabled`, which is referenced immediately afterwards in
    2962                 :            :         // ActivateBestChain, so that we stop connecting blocks past the snapshot base.
    2963         [ #  # ]:          0 :         m_chainman.MaybeCompleteSnapshotValidation();
    2964                 :          0 :     }
    2965                 :            : 
    2966         [ +  - ]:          1 :     connectTrace.BlockConnected(pindexNew, std::move(pthisBlock));
    2967                 :          1 :     return true;
    2968                 :          1 : }
    2969                 :            : 
    2970                 :            : /**
    2971                 :            :  * Return the tip of the chain with the most work in it, that isn't
    2972                 :            :  * known to be invalid (it's however far from certain to be valid).
    2973                 :            :  */
    2974                 :          1 : CBlockIndex* Chainstate::FindMostWorkChain()
    2975                 :            : {
    2976                 :          1 :     AssertLockHeld(::cs_main);
    2977                 :          1 :     do {
    2978                 :          1 :         CBlockIndex *pindexNew = nullptr;
    2979                 :            : 
    2980                 :            :         // Find the best candidate header.
    2981                 :            :         {
    2982                 :          1 :             std::set<CBlockIndex*, CBlockIndexWorkComparator>::reverse_iterator it = setBlockIndexCandidates.rbegin();
    2983         [ +  - ]:          1 :             if (it == setBlockIndexCandidates.rend())
    2984                 :          0 :                 return nullptr;
    2985                 :          1 :             pindexNew = *it;
    2986                 :            :         }
    2987                 :            : 
    2988                 :            :         // Check whether all blocks on the path between the currently active chain and the candidate are valid.
    2989                 :            :         // Just going until the active chain is an optimization, as we know all blocks in it are valid already.
    2990                 :          1 :         CBlockIndex *pindexTest = pindexNew;
    2991                 :          1 :         bool fInvalidAncestor = false;
    2992   [ +  +  +  + ]:          2 :         while (pindexTest && !m_chain.Contains(pindexTest)) {
    2993   [ +  -  +  - ]:          1 :             assert(pindexTest->HaveTxsDownloaded() || pindexTest->nHeight == 0);
    2994                 :            : 
    2995                 :            :             // Pruned nodes may have entries in setBlockIndexCandidates for
    2996                 :            :             // which block files have been deleted.  Remove those as candidates
    2997                 :            :             // for the most work chain if we come across them; we can't switch
    2998                 :            :             // to a chain unless we have all the non-active-chain parent blocks.
    2999                 :          1 :             bool fFailedChain = pindexTest->nStatus & BLOCK_FAILED_MASK;
    3000                 :          1 :             bool fMissingData = !(pindexTest->nStatus & BLOCK_HAVE_DATA);
    3001   [ +  -  -  + ]:          1 :             if (fFailedChain || fMissingData) {
    3002                 :            :                 // Candidate chain is not usable (either invalid or missing data)
    3003   [ #  #  #  #  :          0 :                 if (fFailedChain && (m_chainman.m_best_invalid == nullptr || pindexNew->nChainWork > m_chainman.m_best_invalid->nChainWork)) {
                   #  # ]
    3004                 :          0 :                     m_chainman.m_best_invalid = pindexNew;
    3005                 :          0 :                 }
    3006                 :          0 :                 CBlockIndex *pindexFailed = pindexNew;
    3007                 :            :                 // Remove the entire chain from the set.
    3008         [ #  # ]:          0 :                 while (pindexTest != pindexFailed) {
    3009         [ #  # ]:          0 :                     if (fFailedChain) {
    3010                 :          0 :                         pindexFailed->nStatus |= BLOCK_FAILED_CHILD;
    3011                 :          0 :                         m_blockman.m_dirty_blockindex.insert(pindexFailed);
    3012         [ #  # ]:          0 :                     } else if (fMissingData) {
    3013                 :            :                         // If we're missing data, then add back to m_blocks_unlinked,
    3014                 :            :                         // so that if the block arrives in the future we can try adding
    3015                 :            :                         // to setBlockIndexCandidates again.
    3016                 :          0 :                         m_blockman.m_blocks_unlinked.insert(
    3017                 :          0 :                             std::make_pair(pindexFailed->pprev, pindexFailed));
    3018                 :          0 :                     }
    3019                 :          0 :                     setBlockIndexCandidates.erase(pindexFailed);
    3020                 :          0 :                     pindexFailed = pindexFailed->pprev;
    3021                 :            :                 }
    3022                 :          0 :                 setBlockIndexCandidates.erase(pindexTest);
    3023                 :          0 :                 fInvalidAncestor = true;
    3024                 :          0 :                 break;
    3025                 :            :             }
    3026                 :          1 :             pindexTest = pindexTest->pprev;
    3027                 :            :         }
    3028         [ -  + ]:          1 :         if (!fInvalidAncestor)
    3029                 :          1 :             return pindexNew;
    3030         [ #  # ]:          0 :     } while(true);
    3031                 :          1 : }
    3032                 :            : 
    3033                 :            : /** Delete all entries in setBlockIndexCandidates that are worse than the current tip. */
    3034                 :          1 : void Chainstate::PruneBlockIndexCandidates() {
    3035                 :            :     // Note that we can't delete the current block itself, as we may need to return to it later in case a
    3036                 :            :     // reorganization to a better block fails.
    3037                 :          1 :     std::set<CBlockIndex*, CBlockIndexWorkComparator>::iterator it = setBlockIndexCandidates.begin();
    3038   [ -  +  -  + ]:          1 :     while (it != setBlockIndexCandidates.end() && setBlockIndexCandidates.value_comp()(*it, m_chain.Tip())) {
    3039                 :          0 :         setBlockIndexCandidates.erase(it++);
    3040                 :            :     }
    3041                 :            :     // Either the current tip or a successor of it we're working towards is left in setBlockIndexCandidates.
    3042         [ +  - ]:          1 :     assert(!setBlockIndexCandidates.empty());
    3043                 :          1 : }
    3044                 :            : 
    3045                 :            : /**
    3046                 :            :  * Try to make some progress towards making pindexMostWork the active block.
    3047                 :            :  * pblock is either nullptr or a pointer to a CBlock corresponding to pindexMostWork.
    3048                 :            :  *
    3049                 :            :  * @returns true unless a system error occurred
    3050                 :            :  */
    3051                 :          1 : bool Chainstate::ActivateBestChainStep(BlockValidationState& state, CBlockIndex* pindexMostWork, const std::shared_ptr<const CBlock>& pblock, bool& fInvalidFound, ConnectTrace& connectTrace)
    3052                 :            : {
    3053                 :          1 :     AssertLockHeld(cs_main);
    3054         [ +  - ]:          1 :     if (m_mempool) AssertLockHeld(m_mempool->cs);
    3055                 :            : 
    3056                 :          1 :     const CBlockIndex* pindexOldTip = m_chain.Tip();
    3057                 :          1 :     const CBlockIndex* pindexFork = m_chain.FindFork(pindexMostWork);
    3058                 :            : 
    3059                 :            :     // Disconnect active blocks which are no longer in the best chain.
    3060                 :          1 :     bool fBlocksDisconnected = false;
    3061                 :          1 :     DisconnectedBlockTransactions disconnectpool{MAX_DISCONNECTED_TX_POOL_SIZE * 1000};
    3062   [ +  -  -  +  :          1 :     while (m_chain.Tip() && m_chain.Tip() != pindexFork) {
             #  #  -  + ]
    3063   [ #  #  #  # ]:          0 :         if (!DisconnectTip(state, &disconnectpool)) {
    3064                 :            :             // This is likely a fatal error, but keep the mempool consistent,
    3065                 :            :             // just in case. Only remove from the mempool in this case.
    3066         [ #  # ]:          0 :             MaybeUpdateMempoolForReorg(disconnectpool, false);
    3067                 :            : 
    3068                 :            :             // If we're unable to disconnect a block during normal operation,
    3069                 :            :             // then that is a failure of our local system -- we should abort
    3070                 :            :             // rather than stay on a less work chain.
    3071   [ #  #  #  #  :          0 :             FatalError(m_chainman.GetNotifications(), state, "Failed to disconnect block; see debug.log for details");
                   #  # ]
    3072                 :          0 :             return false;
    3073                 :            :         }
    3074                 :          0 :         fBlocksDisconnected = true;
    3075                 :            :     }
    3076                 :            : 
    3077                 :            :     // Build list of new blocks to connect (in descending height order).
    3078                 :          1 :     std::vector<CBlockIndex*> vpindexToConnect;
    3079                 :          1 :     bool fContinue = true;
    3080         [ -  + ]:          1 :     int nHeight = pindexFork ? pindexFork->nHeight : -1;
    3081   [ +  +  +  + ]:          2 :     while (fContinue && nHeight != pindexMostWork->nHeight) {
    3082                 :            :         // Don't iterate the entire list of potential improvements toward the best tip, as we likely only need
    3083                 :            :         // a few blocks along the way.
    3084         [ +  - ]:          1 :         int nTargetHeight = std::min(nHeight + 32, pindexMostWork->nHeight);
    3085                 :          1 :         vpindexToConnect.clear();
    3086         [ +  - ]:          1 :         vpindexToConnect.reserve(nTargetHeight - nHeight);
    3087         [ +  - ]:          1 :         CBlockIndex* pindexIter = pindexMostWork->GetAncestor(nTargetHeight);
    3088   [ +  +  +  + ]:          2 :         while (pindexIter && pindexIter->nHeight != nHeight) {
    3089         [ +  - ]:          1 :             vpindexToConnect.push_back(pindexIter);
    3090                 :          1 :             pindexIter = pindexIter->pprev;
    3091                 :            :         }
    3092                 :          1 :         nHeight = nTargetHeight;
    3093                 :            : 
    3094                 :            :         // Connect new blocks.
    3095   [ +  -  +  -  :          1 :         for (CBlockIndex* pindexConnect : reverse_iterate(vpindexToConnect)) {
          +  -  +  -  +  
             -  +  -  #  
                      # ]
    3096   [ -  +  +  -  :          1 :             if (!ConnectTip(state, pindexConnect, pindexConnect == pindexMostWork ? pblock : std::shared_ptr<const CBlock>(), connectTrace, disconnectpool)) {
                   -  + ]
    3097   [ #  #  #  # ]:          0 :                 if (state.IsInvalid()) {
    3098                 :            :                     // The block violates a consensus rule.
    3099   [ #  #  #  # ]:          0 :                     if (state.GetResult() != BlockValidationResult::BLOCK_MUTATED) {
    3100         [ #  # ]:          0 :                         InvalidChainFound(vpindexToConnect.front());
    3101                 :          0 :                     }
    3102                 :          0 :                     state = BlockValidationState();
    3103                 :          0 :                     fInvalidFound = true;
    3104                 :          0 :                     fContinue = false;
    3105                 :          0 :                     break;
    3106                 :            :                 } else {
    3107                 :            :                     // A system error occurred (disk space, database error, ...).
    3108                 :            :                     // Make the mempool consistent with the current tip, just in case
    3109                 :            :                     // any observers try to use it before shutdown.
    3110         [ #  # ]:          0 :                     MaybeUpdateMempoolForReorg(disconnectpool, false);
    3111                 :          0 :                     return false;
    3112                 :            :                 }
    3113                 :            :             } else {
    3114         [ +  - ]:          1 :                 PruneBlockIndexCandidates();
    3115   [ -  +  #  #  :          1 :                 if (!pindexOldTip || m_chain.Tip()->nChainWork > pindexOldTip->nChainWork) {
             #  #  #  # ]
    3116                 :            :                     // We're in a better position than we were. Return temporarily to release the lock.
    3117                 :          1 :                     fContinue = false;
    3118                 :          1 :                     break;
    3119                 :            :                 }
    3120                 :            :             }
    3121                 :            :         }
    3122                 :            :     }
    3123                 :            : 
    3124         [ -  + ]:          1 :     if (fBlocksDisconnected) {
    3125                 :            :         // If any blocks were disconnected, disconnectpool may be non empty.  Add
    3126                 :            :         // any disconnected transactions back to the mempool.
    3127         [ #  # ]:          0 :         MaybeUpdateMempoolForReorg(disconnectpool, true);
    3128                 :          0 :     }
    3129   [ +  -  +  -  :          1 :     if (m_mempool) m_mempool->check(this->CoinsTip(), this->m_chain.Height() + 1);
             +  -  +  - ]
    3130                 :            : 
    3131         [ +  - ]:          1 :     CheckForkWarningConditions();
    3132                 :            : 
    3133                 :          1 :     return true;
    3134                 :          1 : }
    3135                 :            : 
    3136                 :          1 : static SynchronizationState GetSynchronizationState(bool init)
    3137                 :            : {
    3138         [ -  + ]:          1 :     if (!init) return SynchronizationState::POST_INIT;
    3139         [ -  + ]:          1 :     if (::fReindex) return SynchronizationState::INIT_REINDEX;
    3140                 :          1 :     return SynchronizationState::INIT_DOWNLOAD;
    3141                 :          1 : }
    3142                 :            : 
    3143                 :          0 : static bool NotifyHeaderTip(ChainstateManager& chainman) LOCKS_EXCLUDED(cs_main)
    3144                 :            : {
    3145                 :          0 :     bool fNotify = false;
    3146                 :          0 :     bool fInitialBlockDownload = false;
    3147                 :            :     static CBlockIndex* pindexHeaderOld = nullptr;
    3148                 :          0 :     CBlockIndex* pindexHeader = nullptr;
    3149                 :            :     {
    3150                 :          0 :         LOCK(cs_main);
    3151                 :          0 :         pindexHeader = chainman.m_best_header;
    3152                 :            : 
    3153         [ #  # ]:          0 :         if (pindexHeader != pindexHeaderOld) {
    3154                 :          0 :             fNotify = true;
    3155         [ #  # ]:          0 :             fInitialBlockDownload = chainman.IsInitialBlockDownload();
    3156                 :          0 :             pindexHeaderOld = pindexHeader;
    3157                 :          0 :         }
    3158                 :          0 :     }
    3159                 :            :     // Send block tip changed notifications without cs_main
    3160         [ #  # ]:          0 :     if (fNotify) {
    3161                 :          0 :         chainman.GetNotifications().headerTip(GetSynchronizationState(fInitialBlockDownload), pindexHeader->nHeight, pindexHeader->nTime, false);
    3162                 :          0 :     }
    3163                 :          0 :     return fNotify;
    3164                 :          0 : }
    3165                 :            : 
    3166                 :          1 : static void LimitValidationInterfaceQueue() LOCKS_EXCLUDED(cs_main) {
    3167                 :          1 :     AssertLockNotHeld(cs_main);
    3168                 :            : 
    3169         [ +  - ]:          1 :     if (GetMainSignals().CallbacksPending() > 10) {
    3170                 :          0 :         SyncWithValidationInterfaceQueue();
    3171                 :          0 :     }
    3172                 :          1 : }
    3173                 :            : 
    3174                 :          1 : bool Chainstate::ActivateBestChain(BlockValidationState& state, std::shared_ptr<const CBlock> pblock)
    3175                 :            : {
    3176                 :          1 :     AssertLockNotHeld(m_chainstate_mutex);
    3177                 :            : 
    3178                 :            :     // Note that while we're often called here from ProcessNewBlock, this is
    3179                 :            :     // far from a guarantee. Things in the P2P/RPC will often end up calling
    3180                 :            :     // us in the middle of ProcessNewBlock - do not assume pblock is set
    3181                 :            :     // sanely for performance or correctness!
    3182                 :          1 :     AssertLockNotHeld(::cs_main);
    3183                 :            : 
    3184                 :            :     // ABC maintains a fair degree of expensive-to-calculate internal state
    3185                 :            :     // because this function periodically releases cs_main so that it does not lock up other threads for too long
    3186                 :            :     // during large connects - and to allow for e.g. the callback queue to drain
    3187                 :            :     // we use m_chainstate_mutex to enforce mutual exclusion so that only one caller may execute this function at a time
    3188                 :          1 :     LOCK(m_chainstate_mutex);
    3189                 :            : 
    3190                 :            :     // Belt-and-suspenders check that we aren't attempting to advance the background
    3191                 :            :     // chainstate past the snapshot base block.
    3192   [ +  -  +  -  :          2 :     if (WITH_LOCK(::cs_main, return m_disabled)) {
                   -  + ]
    3193   [ #  #  #  #  :          0 :         LogPrintf("m_disabled is set - this chainstate should not be in operation. "
                   #  # ]
    3194                 :            :             "Please report this as a bug. %s\n", PACKAGE_BUGREPORT);
    3195                 :          0 :         return false;
    3196                 :            :     }
    3197                 :            : 
    3198                 :          1 :     CBlockIndex *pindexMostWork = nullptr;
    3199                 :          1 :     CBlockIndex *pindexNewTip = nullptr;
    3200                 :          1 :     bool exited_ibd{false};
    3201                 :          1 :     do {
    3202                 :            :         // Block until the validation queue drains. This should largely
    3203                 :            :         // never happen in normal operation, however may happen during
    3204                 :            :         // reindex, causing memory blowup if we run too far ahead.
    3205                 :            :         // Note that if a validationinterface callback ends up calling
    3206                 :            :         // ActivateBestChain this may lead to a deadlock! We should
    3207                 :            :         // probably have a DEBUG_LOCKORDER test for this in the future.
    3208         [ +  + ]:          2 :         LimitValidationInterfaceQueue();
    3209                 :            : 
    3210                 :            :         {
    3211   [ +  -  +  - ]:          1 :             LOCK(cs_main);
    3212                 :            :             // Lock transaction pool for at least as long as it takes for connectTrace to be consumed
    3213   [ +  -  +  -  :          1 :             LOCK(MempoolMutex());
                   +  - ]
    3214         [ +  - ]:          1 :             const bool was_in_ibd = m_chainman.IsInitialBlockDownload();
    3215         [ +  - ]:          1 :             CBlockIndex* starting_tip = m_chain.Tip();
    3216                 :          1 :             bool blocks_connected = false;
    3217                 :          1 :             do {
    3218                 :            :                 // We absolutely may not unlock cs_main until we've made forward progress
    3219                 :            :                 // (with the exception of shutdown due to hardware issues, low disk space, etc).
    3220         [ +  - ]:          1 :                 ConnectTrace connectTrace; // Destructed before cs_main is unlocked
    3221                 :            : 
    3222         [ +  - ]:          1 :                 if (pindexMostWork == nullptr) {
    3223         [ +  - ]:          1 :                     pindexMostWork = FindMostWorkChain();
    3224                 :          1 :                 }
    3225                 :            : 
    3226                 :            :                 // Whether we have anything to do at all.
    3227   [ -  +  +  -  :          1 :                 if (pindexMostWork == nullptr || pindexMostWork == m_chain.Tip()) {
                   -  + ]
    3228                 :          0 :                     break;
    3229                 :            :                 }
    3230                 :            : 
    3231                 :          1 :                 bool fInvalidFound = false;
    3232                 :          1 :                 std::shared_ptr<const CBlock> nullBlockPtr;
    3233   [ +  -  -  +  :          1 :                 if (!ActivateBestChainStep(state, pindexMostWork, pblock && pblock->GetHash() == pindexMostWork->GetBlockHash() ? pblock : nullBlockPtr, fInvalidFound, connectTrace)) {
          #  #  #  #  #  
          #  #  #  +  -  
                   +  - ]
    3234                 :            :                     // A system error occurred
    3235                 :          0 :                     return false;
    3236                 :            :                 }
    3237                 :          1 :                 blocks_connected = true;
    3238                 :            : 
    3239         [ +  - ]:          1 :                 if (fInvalidFound) {
    3240                 :            :                     // Wipe cache, we may need another branch now.
    3241                 :          0 :                     pindexMostWork = nullptr;
    3242                 :          0 :                 }
    3243         [ +  - ]:          1 :                 pindexNewTip = m_chain.Tip();
    3244                 :            : 
    3245   [ +  -  +  + ]:          2 :                 for (const PerBlockConnectTrace& trace : connectTrace.GetBlocksConnected()) {
    3246   [ +  -  -  +  :          1 :                     assert(trace.pblock && trace.pindex);
                   +  - ]
    3247   [ +  -  +  -  :          1 :                     GetMainSignals().BlockConnected(this->GetRole(), trace.pblock, trace.pindex);
                   +  - ]
    3248                 :            :                 }
    3249                 :            : 
    3250                 :            :                 // This will have been toggled in
    3251                 :            :                 // ActivateBestChainStep -> ConnectTip -> MaybeCompleteSnapshotValidation,
    3252                 :            :                 // if at all, so we should catch it here.
    3253                 :            :                 //
    3254                 :            :                 // Break this do-while to ensure we don't advance past the base snapshot.
    3255         [ -  + ]:          1 :                 if (m_disabled) {
    3256                 :          0 :                     break;
    3257                 :            :                 }
    3258   [ -  -  +  +  :          1 :             } while (!m_chain.Tip() || (starting_tip && CBlockIndexWorkComparator()(m_chain.Tip(), starting_tip)));
          -  -  +  -  +  
          #  #  #  #  -  
                      + ]
    3259         [ +  - ]:          1 :             if (!blocks_connected) return true;
    3260                 :            : 
    3261         [ +  - ]:          1 :             const CBlockIndex* pindexFork = m_chain.FindFork(starting_tip);
    3262         [ +  - ]:          1 :             bool still_in_ibd = m_chainman.IsInitialBlockDownload();
    3263                 :            : 
    3264   [ +  -  +  - ]:          1 :             if (was_in_ibd && !still_in_ibd) {
    3265                 :            :                 // Active chainstate has exited IBD.
    3266                 :          0 :                 exited_ibd = true;
    3267                 :          0 :             }
    3268                 :            : 
    3269                 :            :             // Notify external listeners about the new tip.
    3270                 :            :             // Enqueue while holding cs_main to ensure that UpdatedBlockTip is called in the order in which blocks are connected
    3271   [ +  -  +  -  :          1 :             if (this == &m_chainman.ActiveChainstate() && pindexFork != pindexNewTip) {
                   +  - ]
    3272                 :            :                 // Notify ValidationInterface subscribers
    3273   [ +  -  +  - ]:          1 :                 GetMainSignals().UpdatedBlockTip(pindexNewTip, pindexFork, still_in_ibd);
    3274                 :            : 
    3275                 :            :                 // Always notify the UI if a new block tip was connected
    3276   [ +  -  +  -  :          1 :                 if (kernel::IsInterrupted(m_chainman.GetNotifications().blockTip(GetSynchronizationState(still_in_ibd), *pindexNewTip))) {
          +  -  +  -  -  
                      + ]
    3277                 :            :                     // Just breaking and returning success for now. This could
    3278                 :            :                     // be changed to bubble up the kernel::Interrupted value to
    3279                 :            :                     // the caller so the caller could distinguish between
    3280                 :            :                     // completed and interrupted operations.
    3281                 :          0 :                     break;
    3282                 :            :                 }
    3283                 :          1 :             }
    3284      [ +  +  + ]:          1 :         }
    3285                 :            :         // When we reach this point, we switched to a new tip (stored in pindexNewTip).
    3286                 :            : 
    3287         [ -  + ]:          1 :         if (exited_ibd) {
    3288                 :            :             // If a background chainstate is in use, we may need to rebalance our
    3289                 :            :             // allocation of caches once a chainstate exits initial block download.
    3290   [ #  #  #  # ]:          0 :             LOCK(::cs_main);
    3291         [ #  # ]:          0 :             m_chainman.MaybeRebalanceCaches();
    3292                 :          0 :         }
    3293                 :            : 
    3294   [ +  -  +  -  :          2 :         if (WITH_LOCK(::cs_main, return m_disabled)) {
                   +  - ]
    3295                 :            :             // Background chainstate has reached the snapshot base block, so exit.
    3296                 :            : 
    3297                 :            :             // Restart indexes to resume indexing for all blocks unique to the snapshot
    3298                 :            :             // chain. This resumes indexing "in order" from where the indexing on the
    3299                 :            :             // background validation chain left off.
    3300                 :            :             //
    3301                 :            :             // This cannot be done while holding cs_main (within
    3302                 :            :             // MaybeCompleteSnapshotValidation) or a cs_main deadlock will occur.
    3303         [ #  # ]:          0 :             if (m_chainman.restart_indexes) {
    3304         [ #  # ]:          0 :                 m_chainman.restart_indexes();
    3305                 :          0 :             }
    3306                 :          0 :             break;
    3307                 :            :         }
    3308                 :            : 
    3309                 :            :         // We check interrupt only after giving ActivateBestChainStep a chance to run once so that we
    3310                 :            :         // never interrupt before connecting the genesis block during LoadChainTip(). Previously this
    3311                 :            :         // caused an assert() failure during interrupt in such cases as the UTXO DB flushing checks
    3312                 :            :         // that the best block hash is non-null.
    3313   [ +  -  +  - ]:          1 :         if (m_chainman.m_interrupt) break;
    3314                 :          1 :     } while (pindexNewTip != pindexMostWork);
    3315                 :            : 
    3316         [ +  + ]:          2 :     m_chainman.CheckBlockIndex();
    3317                 :            : 
    3318                 :            :     // Write changes periodically to disk, after relay.
    3319   [ +  -  +  - ]:          1 :     if (!FlushStateToDisk(state, FlushStateMode::PERIODIC)) {
    3320                 :          0 :         return false;
    3321                 :            :     }
    3322                 :            : 
    3323                 :          1 :     return true;
    3324                 :          5 : }
    3325                 :            : 
    3326                 :          0 : bool Chainstate::PreciousBlock(BlockValidationState& state, CBlockIndex* pindex)
    3327                 :            : {
    3328                 :          0 :     AssertLockNotHeld(m_chainstate_mutex);
    3329                 :          0 :     AssertLockNotHeld(::cs_main);
    3330                 :            :     {
    3331                 :          0 :         LOCK(cs_main);
    3332   [ #  #  #  #  :          0 :         if (pindex->nChainWork < m_chain.Tip()->nChainWork) {
                   #  # ]
    3333                 :            :             // Nothing to do, this block is not at the tip.
    3334                 :          0 :             return true;
    3335                 :            :         }
    3336   [ #  #  #  #  :          0 :         if (m_chain.Tip()->nChainWork > m_chainman.nLastPreciousChainwork) {
                   #  # ]
    3337                 :            :             // The chain has been extended since the last call, reset the counter.
    3338                 :          0 :             m_chainman.nBlockReverseSequenceId = -1;
    3339                 :          0 :         }
    3340   [ #  #  #  # ]:          0 :         m_chainman.nLastPreciousChainwork = m_chain.Tip()->nChainWork;
    3341         [ #  # ]:          0 :         setBlockIndexCandidates.erase(pindex);
    3342                 :          0 :         pindex->nSequenceId = m_chainman.nBlockReverseSequenceId;
    3343         [ #  # ]:          0 :         if (m_chainman.nBlockReverseSequenceId > std::numeric_limits<int32_t>::min()) {
    3344                 :            :             // We can't keep reducing the counter if somebody really wants to
    3345                 :            :             // call preciousblock 2**31-1 times on the same set of tips...
    3346                 :          0 :             m_chainman.nBlockReverseSequenceId--;
    3347                 :          0 :         }
    3348   [ #  #  #  #  :          0 :         if (pindex->IsValid(BLOCK_VALID_TRANSACTIONS) && pindex->HaveTxsDownloaded()) {
             #  #  #  # ]
    3349         [ #  # ]:          0 :             setBlockIndexCandidates.insert(pindex);
    3350         [ #  # ]:          0 :             PruneBlockIndexCandidates();
    3351                 :          0 :         }
    3352      [ #  #  # ]:          0 :     }
    3353                 :            : 
    3354         [ #  # ]:          0 :     return ActivateBestChain(state, std::shared_ptr<const CBlock>());
    3355                 :          0 : }
    3356                 :            : 
    3357                 :          0 : bool Chainstate::InvalidateBlock(BlockValidationState& state, CBlockIndex* pindex)
    3358                 :            : {
    3359                 :          0 :     AssertLockNotHeld(m_chainstate_mutex);
    3360                 :          0 :     AssertLockNotHeld(::cs_main);
    3361                 :            : 
    3362                 :            :     // Genesis block can't be invalidated
    3363         [ #  # ]:          0 :     assert(pindex);
    3364         [ #  # ]:          0 :     if (pindex->nHeight == 0) return false;
    3365                 :            : 
    3366                 :          0 :     CBlockIndex* to_mark_failed = pindex;
    3367                 :          0 :     bool pindex_was_in_chain = false;
    3368                 :          0 :     int disconnected = 0;
    3369                 :            : 
    3370                 :            :     // We do not allow ActivateBestChain() to run while InvalidateBlock() is
    3371                 :            :     // running, as that could cause the tip to change while we disconnect
    3372                 :            :     // blocks.
    3373                 :          0 :     LOCK(m_chainstate_mutex);
    3374                 :            : 
    3375                 :            :     // We'll be acquiring and releasing cs_main below, to allow the validation
    3376                 :            :     // callbacks to run. However, we should keep the block index in a
    3377                 :            :     // consistent state as we disconnect blocks -- in particular we need to
    3378                 :            :     // add equal-work blocks to setBlockIndexCandidates as we disconnect.
    3379                 :            :     // To avoid walking the block index repeatedly in search of candidates,
    3380                 :            :     // build a map once so that we can look up candidate blocks by chain
    3381                 :            :     // work as we go.
    3382                 :          0 :     std::multimap<const arith_uint256, CBlockIndex *> candidate_blocks_by_work;
    3383                 :            : 
    3384                 :            :     {
    3385   [ #  #  #  # ]:          0 :         LOCK(cs_main);
    3386         [ #  # ]:          0 :         for (auto& entry : m_blockman.m_block_index) {
    3387                 :          0 :             CBlockIndex* candidate = &entry.second;
    3388                 :            :             // We don't need to put anything in our active chain into the
    3389                 :            :             // multimap, because those candidates will be found and considered
    3390                 :            :             // as we disconnect.
    3391                 :            :             // Instead, consider only non-active-chain blocks that have at
    3392                 :            :             // least as much work as where we expect the new tip to end up.
    3393   [ #  #  #  #  :          0 :             if (!m_chain.Contains(candidate) &&
                   #  # ]
    3394   [ #  #  #  # ]:          0 :                     !CBlockIndexWorkComparator()(candidate, pindex->pprev) &&
    3395   [ #  #  #  # ]:          0 :                     candidate->IsValid(BLOCK_VALID_TRANSACTIONS) &&
    3396         [ #  # ]:          0 :                     candidate->HaveTxsDownloaded()) {
    3397   [ #  #  #  # ]:          0 :                 candidate_blocks_by_work.insert(std::make_pair(candidate->nChainWork, candidate));
    3398                 :          0 :             }
    3399                 :            :         }
    3400                 :          0 :     }
    3401                 :            : 
    3402                 :            :     // Disconnect (descendants of) pindex, and mark them invalid.
    3403                 :          0 :     while (true) {
    3404   [ #  #  #  # ]:          0 :         if (m_chainman.m_interrupt) break;
    3405                 :            : 
    3406                 :            :         // Make sure the queue of validation callbacks doesn't grow unboundedly.
    3407         [ #  # ]:          0 :         LimitValidationInterfaceQueue();
    3408                 :            : 
    3409   [ #  #  #  # ]:          0 :         LOCK(cs_main);
    3410                 :            :         // Lock for as long as disconnectpool is in scope to make sure MaybeUpdateMempoolForReorg is
    3411                 :            :         // called after DisconnectTip without unlocking in between
    3412   [ #  #  #  #  :          0 :         LOCK(MempoolMutex());
                   #  # ]
    3413   [ #  #  #  # ]:          0 :         if (!m_chain.Contains(pindex)) break;
    3414                 :          0 :         pindex_was_in_chain = true;
    3415         [ #  # ]:          0 :         CBlockIndex *invalid_walk_tip = m_chain.Tip();
    3416                 :            : 
    3417                 :            :         // ActivateBestChain considers blocks already in m_chain
    3418                 :            :         // unconditionally valid already, so force disconnect away from it.
    3419         [ #  # ]:          0 :         DisconnectedBlockTransactions disconnectpool{MAX_DISCONNECTED_TX_POOL_SIZE * 1000};
    3420         [ #  # ]:          0 :         bool ret = DisconnectTip(state, &disconnectpool);
    3421                 :            :         // DisconnectTip will add transactions to disconnectpool.
    3422                 :            :         // Adjust the mempool to be consistent with the new tip, adding
    3423                 :            :         // transactions back to the mempool if disconnecting was successful,
    3424                 :            :         // and we're not doing a very deep invalidation (in which case
    3425                 :            :         // keeping the mempool up to date is probably futile anyway).
    3426   [ #  #  #  # ]:          0 :         MaybeUpdateMempoolForReorg(disconnectpool, /* fAddToMempool = */ (++disconnected <= 10) && ret);
    3427         [ #  # ]:          0 :         if (!ret) return false;
    3428   [ #  #  #  # ]:          0 :         assert(invalid_walk_tip->pprev == m_chain.Tip());
    3429                 :            : 
    3430                 :            :         // We immediately mark the disconnected blocks as invalid.
    3431                 :            :         // This prevents a case where pruned nodes may fail to invalidateblock
    3432                 :            :         // and be left unable to start as they have no tip candidates (as there
    3433                 :            :         // are no blocks that meet the "have data and are not invalid per
    3434                 :            :         // nStatus" criteria for inclusion in setBlockIndexCandidates).
    3435                 :          0 :         invalid_walk_tip->nStatus |= BLOCK_FAILED_VALID;
    3436         [ #  # ]:          0 :         m_blockman.m_dirty_blockindex.insert(invalid_walk_tip);
    3437         [ #  # ]:          0 :         setBlockIndexCandidates.erase(invalid_walk_tip);
    3438         [ #  # ]:          0 :         setBlockIndexCandidates.insert(invalid_walk_tip->pprev);
    3439   [ #  #  #  # ]:          0 :         if (invalid_walk_tip->pprev == to_mark_failed && (to_mark_failed->nStatus & BLOCK_FAILED_VALID)) {
    3440                 :            :             // We only want to mark the last disconnected block as BLOCK_FAILED_VALID; its children
    3441                 :            :             // need to be BLOCK_FAILED_CHILD instead.
    3442                 :          0 :             to_mark_failed->nStatus = (to_mark_failed->nStatus ^ BLOCK_FAILED_VALID) | BLOCK_FAILED_CHILD;
    3443         [ #  # ]:          0 :             m_blockman.m_dirty_blockindex.insert(to_mark_failed);
    3444                 :          0 :         }
    3445                 :            : 
    3446                 :            :         // Add any equal or more work headers to setBlockIndexCandidates
    3447         [ #  # ]:          0 :         auto candidate_it = candidate_blocks_by_work.lower_bound(invalid_walk_tip->pprev->nChainWork);
    3448         [ #  # ]:          0 :         while (candidate_it != candidate_blocks_by_work.end()) {
    3449   [ #  #  #  # ]:          0 :             if (!CBlockIndexWorkComparator()(candidate_it->second, invalid_walk_tip->pprev)) {
    3450         [ #  # ]:          0 :                 setBlockIndexCandidates.insert(candidate_it->second);
    3451         [ #  # ]:          0 :                 candidate_it = candidate_blocks_by_work.erase(candidate_it);
    3452                 :          0 :             } else {
    3453                 :          0 :                 ++candidate_it;
    3454                 :            :             }
    3455                 :            :         }
    3456                 :            : 
    3457                 :            :         // Track the last disconnected block, so we can correct its BLOCK_FAILED_CHILD status in future
    3458                 :            :         // iterations, or, if it's the last one, call InvalidChainFound on it.
    3459                 :          0 :         to_mark_failed = invalid_walk_tip;
    3460      [ #  #  # ]:          0 :     }
    3461                 :            : 
    3462         [ #  # ]:          0 :     m_chainman.CheckBlockIndex();
    3463                 :            : 
    3464                 :            :     {
    3465   [ #  #  #  # ]:          0 :         LOCK(cs_main);
    3466   [ #  #  #  # ]:          0 :         if (m_chain.Contains(to_mark_failed)) {
    3467                 :            :             // If the to-be-marked invalid block is in the active chain, something is interfering and we can't proceed.
    3468                 :          0 :             return false;
    3469                 :            :         }
    3470                 :            : 
    3471                 :            :         // Mark pindex (or the last disconnected block) as invalid, even when it never was in the main chain
    3472                 :          0 :         to_mark_failed->nStatus |= BLOCK_FAILED_VALID;
    3473         [ #  # ]:          0 :         m_blockman.m_dirty_blockindex.insert(to_mark_failed);
    3474         [ #  # ]:          0 :         setBlockIndexCandidates.erase(to_mark_failed);
    3475         [ #  # ]:          0 :         m_chainman.m_failed_blocks.insert(to_mark_failed);
    3476                 :            : 
    3477                 :            :         // If any new blocks somehow arrived while we were disconnecting
    3478                 :            :         // (above), then the pre-calculation of what should go into
    3479                 :            :         // setBlockIndexCandidates may have missed entries. This would
    3480                 :            :         // technically be an inconsistency in the block index, but if we clean
    3481                 :            :         // it up here, this should be an essentially unobservable error.
    3482                 :            :         // Loop back over all block index entries and add any missing entries
    3483                 :            :         // to setBlockIndexCandidates.
    3484         [ #  # ]:          0 :         for (auto& [_, block_index] : m_blockman.m_block_index) {
    3485   [ #  #  #  #  :          0 :             if (block_index.IsValid(BLOCK_VALID_TRANSACTIONS) && block_index.HaveTxsDownloaded() && !setBlockIndexCandidates.value_comp()(&block_index, m_chain.Tip())) {
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    3486   [ #  #  #  # ]:          0 :                 setBlockIndexCandidates.insert(&block_index);
    3487                 :          0 :             }
    3488                 :            :         }
    3489                 :            : 
    3490         [ #  # ]:          0 :         InvalidChainFound(to_mark_failed);
    3491         [ #  # ]:          0 :     }
    3492                 :            : 
    3493                 :            :     // Only notify about a new block tip if the active chain was modified.
    3494         [ #  # ]:          0 :     if (pindex_was_in_chain) {
    3495                 :            :         // Ignoring return value for now, this could be changed to bubble up
    3496                 :            :         // kernel::Interrupted value to the caller so the caller could
    3497                 :            :         // distinguish between completed and interrupted operations. It might
    3498                 :            :         // also make sense for the blockTip notification to have an enum
    3499                 :            :         // parameter indicating the source of the tip change so hooks can
    3500                 :            :         // distinguish user-initiated invalidateblock changes from other
    3501                 :            :         // changes.
    3502   [ #  #  #  #  :          0 :         (void)m_chainman.GetNotifications().blockTip(GetSynchronizationState(m_chainman.IsInitialBlockDownload()), *to_mark_failed->pprev);
             #  #  #  # ]
    3503                 :          0 :     }
    3504                 :          0 :     return true;
    3505                 :          0 : }
    3506                 :            : 
    3507                 :          0 : void Chainstate::ResetBlockFailureFlags(CBlockIndex *pindex) {
    3508                 :          0 :     AssertLockHeld(cs_main);
    3509                 :            : 
    3510                 :          0 :     int nHeight = pindex->nHeight;
    3511                 :            : 
    3512                 :            :     // Remove the invalidity flag from this block and all its descendants.
    3513         [ #  # ]:          0 :     for (auto& [_, block_index] : m_blockman.m_block_index) {
    3514   [ #  #  #  # ]:          0 :         if (!block_index.IsValid() && block_index.GetAncestor(nHeight) == pindex) {
    3515                 :          0 :             block_index.nStatus &= ~BLOCK_FAILED_MASK;
    3516                 :          0 :             m_blockman.m_dirty_blockindex.insert(&block_index);
    3517   [ #  #  #  #  :          0 :             if (block_index.IsValid(BLOCK_VALID_TRANSACTIONS) && block_index.HaveTxsDownloaded() && setBlockIndexCandidates.value_comp()(m_chain.Tip(), &block_index)) {
                   #  # ]
    3518                 :          0 :                 setBlockIndexCandidates.insert(&block_index);
    3519                 :          0 :             }
    3520         [ #  # ]:          0 :             if (&block_index == m_chainman.m_best_invalid) {
    3521                 :            :                 // Reset invalid block marker if it was pointing to one of those.
    3522                 :          0 :                 m_chainman.m_best_invalid = nullptr;
    3523                 :          0 :             }
    3524                 :          0 :             m_chainman.m_failed_blocks.erase(&block_index);
    3525                 :          0 :         }
    3526                 :            :     }
    3527                 :            : 
    3528                 :            :     // Remove the invalidity flag from all ancestors too.
    3529         [ #  # ]:          0 :     while (pindex != nullptr) {
    3530         [ #  # ]:          0 :         if (pindex->nStatus & BLOCK_FAILED_MASK) {
    3531                 :          0 :             pindex->nStatus &= ~BLOCK_FAILED_MASK;
    3532                 :          0 :             m_blockman.m_dirty_blockindex.insert(pindex);
    3533                 :          0 :             m_chainman.m_failed_blocks.erase(pindex);
    3534                 :          0 :         }
    3535                 :          0 :         pindex = pindex->pprev;
    3536                 :            :     }
    3537                 :          0 : }
    3538                 :            : 
    3539                 :          1 : void Chainstate::TryAddBlockIndexCandidate(CBlockIndex* pindex)
    3540                 :            : {
    3541                 :          1 :     AssertLockHeld(cs_main);
    3542                 :            :     // The block only is a candidate for the most-work-chain if it has the same
    3543                 :            :     // or more work than our current tip.
    3544   [ +  -  -  + ]:          1 :     if (m_chain.Tip() != nullptr && setBlockIndexCandidates.value_comp()(pindex, m_chain.Tip())) {
    3545                 :          0 :         return;
    3546                 :            :     }
    3547                 :            : 
    3548                 :          1 :     bool is_active_chainstate = this == &m_chainman.ActiveChainstate();
    3549         [ +  - ]:          1 :     if (is_active_chainstate) {
    3550                 :            :         // The active chainstate should always add entries that have more
    3551                 :            :         // work than the tip.
    3552                 :          1 :         setBlockIndexCandidates.insert(pindex);
    3553         [ #  # ]:          1 :     } else if (!m_disabled) {
    3554                 :            :         // For the background chainstate, we only consider connecting blocks
    3555                 :            :         // towards the snapshot base (which can't be nullptr or else we'll
    3556                 :            :         // never make progress).
    3557                 :          0 :         const CBlockIndex* snapshot_base{Assert(m_chainman.GetSnapshotBaseBlock())};
    3558         [ #  # ]:          0 :         if (snapshot_base->GetAncestor(pindex->nHeight) == pindex) {
    3559                 :          0 :             setBlockIndexCandidates.insert(pindex);
    3560                 :          0 :         }
    3561                 :          0 :     }
    3562                 :          1 : }
    3563                 :            : 
    3564                 :            : /** Mark a block as having its data received and checked (up to BLOCK_VALID_TRANSACTIONS). */
    3565                 :          1 : void ChainstateManager::ReceivedBlockTransactions(const CBlock& block, CBlockIndex* pindexNew, const FlatFilePos& pos)
    3566                 :            : {
    3567                 :          1 :     AssertLockHeld(cs_main);
    3568                 :          1 :     pindexNew->nTx = block.vtx.size();
    3569                 :          1 :     pindexNew->nChainTx = 0;
    3570                 :          1 :     pindexNew->nFile = pos.nFile;
    3571                 :          1 :     pindexNew->nDataPos = pos.nPos;
    3572                 :          1 :     pindexNew->nUndoPos = 0;
    3573                 :          1 :     pindexNew->nStatus |= BLOCK_HAVE_DATA;
    3574         [ -  + ]:          1 :     if (DeploymentActiveAt(*pindexNew, *this, Consensus::DEPLOYMENT_SEGWIT)) {
    3575                 :          1 :         pindexNew->nStatus |= BLOCK_OPT_WITNESS;
    3576                 :          1 :     }
    3577                 :          1 :     pindexNew->RaiseValidity(BLOCK_VALID_TRANSACTIONS);
    3578                 :          1 :     m_blockman.m_dirty_blockindex.insert(pindexNew);
    3579                 :            : 
    3580   [ -  +  #  # ]:          1 :     if (pindexNew->pprev == nullptr || pindexNew->pprev->HaveTxsDownloaded()) {
    3581                 :            :         // If pindexNew is the genesis block or all parents are BLOCK_VALID_TRANSACTIONS.
    3582                 :          1 :         std::deque<CBlockIndex*> queue;
    3583         [ +  - ]:          1 :         queue.push_back(pindexNew);
    3584                 :            : 
    3585                 :            :         // Recursively process any descendant blocks that now may be eligible to be connected.
    3586         [ +  + ]:          2 :         while (!queue.empty()) {
    3587                 :          1 :             CBlockIndex *pindex = queue.front();
    3588                 :          1 :             queue.pop_front();
    3589         [ -  + ]:          1 :             pindex->nChainTx = (pindex->pprev ? pindex->pprev->nChainTx : 0) + pindex->nTx;
    3590                 :          1 :             pindex->nSequenceId = nBlockSequenceId++;
    3591   [ +  -  +  + ]:          2 :             for (Chainstate *c : GetAll()) {
    3592         [ +  - ]:          1 :                 c->TryAddBlockIndexCandidate(pindex);
    3593                 :            :             }
    3594         [ +  - ]:          1 :             std::pair<std::multimap<CBlockIndex*, CBlockIndex*>::iterator, std::multimap<CBlockIndex*, CBlockIndex*>::iterator> range = m_blockman.m_blocks_unlinked.equal_range(pindex);
    3595         [ -  + ]:          1 :             while (range.first != range.second) {
    3596                 :          0 :                 std::multimap<CBlockIndex*, CBlockIndex*>::iterator it = range.first;
    3597         [ #  # ]:          0 :                 queue.push_back(it->second);
    3598                 :          0 :                 range.first++;
    3599         [ #  # ]:          0 :                 m_blockman.m_blocks_unlinked.erase(it);
    3600                 :            :             }
    3601                 :            :         }
    3602                 :          1 :     } else {
    3603   [ #  #  #  # ]:          0 :         if (pindexNew->pprev && pindexNew->pprev->IsValid(BLOCK_VALID_TREE)) {
    3604                 :          0 :             m_blockman.m_blocks_unlinked.insert(std::make_pair(pindexNew->pprev, pindexNew));
    3605                 :          0 :         }
    3606                 :            :     }
    3607                 :          1 : }
    3608                 :            : 
    3609                 :          1 : static bool CheckBlockHeader(const CBlockHeader& block, BlockValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW = true)
    3610                 :            : {
    3611                 :            :     // Check proof of work matches claimed amount
    3612   [ +  -  +  - ]:          1 :     if (fCheckPOW && !CheckProofOfWork(block.GetHash(), block.nBits, consensusParams))
    3613   [ #  #  #  #  :          0 :         return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "high-hash", "proof of work failed");
                   #  # ]
    3614                 :            : 
    3615                 :          1 :     return true;
    3616                 :          1 : }
    3617                 :            : 
    3618                 :          1 : bool CheckBlock(const CBlock& block, BlockValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW, bool fCheckMerkleRoot)
    3619                 :            : {
    3620                 :            :     // These are checks that are independent of context.
    3621                 :            : 
    3622         [ -  + ]:          1 :     if (block.fChecked)
    3623                 :          0 :         return true;
    3624                 :            : 
    3625                 :            :     // Check that the header is valid (particularly PoW).  This is mostly
    3626                 :            :     // redundant with the call in AcceptBlockHeader.
    3627         [ +  - ]:          1 :     if (!CheckBlockHeader(block, state, consensusParams, fCheckPOW))
    3628                 :          0 :         return false;
    3629                 :            : 
    3630                 :            :     // Signet only: check block solution
    3631   [ -  +  #  #  :          1 :     if (consensusParams.signet_blocks && fCheckPOW && !CheckSignetBlockSolution(block, consensusParams)) {
                   #  # ]
    3632   [ #  #  #  #  :          0 :         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-signet-blksig", "signet block signature validation failure");
                   #  # ]
    3633                 :            :     }
    3634                 :            : 
    3635                 :            :     // Check the merkle root.
    3636         [ -  + ]:          1 :     if (fCheckMerkleRoot) {
    3637                 :            :         bool mutated;
    3638                 :          1 :         uint256 hashMerkleRoot2 = BlockMerkleRoot(block, &mutated);
    3639         [ -  + ]:          1 :         if (block.hashMerkleRoot != hashMerkleRoot2)
    3640   [ #  #  #  #  :          0 :             return state.Invalid(BlockValidationResult::BLOCK_MUTATED, "bad-txnmrklroot", "hashMerkleRoot mismatch");
                   #  # ]
    3641                 :            : 
    3642                 :            :         // Check for merkle tree malleability (CVE-2012-2459): repeating sequences
    3643                 :            :         // of transactions in a block without affecting the merkle root of a block,
    3644                 :            :         // while still invalidating it.
    3645         [ -  + ]:          1 :         if (mutated)
    3646   [ #  #  #  #  :          0 :             return state.Invalid(BlockValidationResult::BLOCK_MUTATED, "bad-txns-duplicate", "duplicate transaction");
                   #  # ]
    3647                 :          1 :     }
    3648                 :            : 
    3649                 :            :     // All potential-corruption validation must be done before we do any
    3650                 :            :     // transaction validation, as otherwise we may mark the header as invalid
    3651                 :            :     // because we receive the wrong transactions for it.
    3652                 :            :     // Note that witness malleability is checked in ContextualCheckBlock, so no
    3653                 :            :     // checks that use witness data may be performed here.
    3654                 :            : 
    3655                 :            :     // Size limits
    3656   [ +  -  +  -  :          1 :     if (block.vtx.empty() || block.vtx.size() * WITNESS_SCALE_FACTOR > MAX_BLOCK_WEIGHT || ::GetSerializeSize(block, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS) * WITNESS_SCALE_FACTOR > MAX_BLOCK_WEIGHT)
                   -  + ]
    3657   [ #  #  #  #  :          0 :         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-blk-length", "size limits failed");
                   #  # ]
    3658                 :            : 
    3659                 :            :     // First transaction must be coinbase, the rest must not be
    3660   [ +  -  -  + ]:          1 :     if (block.vtx.empty() || !block.vtx[0]->IsCoinBase())
    3661   [ #  #  #  #  :          0 :         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-cb-missing", "first tx is not coinbase");
                   #  # ]
    3662         [ -  + ]:          1 :     for (unsigned int i = 1; i < block.vtx.size(); i++)
    3663         [ #  # ]:          0 :         if (block.vtx[i]->IsCoinBase())
    3664   [ #  #  #  #  :          0 :             return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-cb-multiple", "more than one coinbase");
                   #  # ]
    3665                 :            : 
    3666                 :            :     // Check transactions
    3667                 :            :     // Must check for duplicate inputs (see CVE-2018-17144)
    3668         [ +  + ]:          2 :     for (const auto& tx : block.vtx) {
    3669                 :          1 :         TxValidationState tx_state;
    3670   [ +  -  -  + ]:          1 :         if (!CheckTransaction(*tx, tx_state)) {
    3671                 :            :             // CheckBlock() does context-free validation checks. The only
    3672                 :            :             // possible failures are consensus failures.
    3673   [ #  #  #  # ]:          0 :             assert(tx_state.GetResult() == TxValidationResult::TX_CONSENSUS);
    3674   [ #  #  #  # ]:          0 :             return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
    3675   [ #  #  #  #  :          0 :                                  strprintf("Transaction check failed (tx hash %s) %s", tx->GetHash().ToString(), tx_state.GetDebugMessage()));
             #  #  #  # ]
    3676                 :            :         }
    3677      [ -  -  + ]:          1 :     }
    3678                 :          1 :     unsigned int nSigOps = 0;
    3679         [ +  + ]:          2 :     for (const auto& tx : block.vtx)
    3680                 :            :     {
    3681                 :          1 :         nSigOps += GetLegacySigOpCount(*tx);
    3682                 :            :     }
    3683         [ -  + ]:          1 :     if (nSigOps * WITNESS_SCALE_FACTOR > MAX_BLOCK_SIGOPS_COST)
    3684   [ #  #  #  #  :          0 :         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-blk-sigops", "out-of-bounds SigOpCount");
                   #  # ]
    3685                 :            : 
    3686   [ +  -  -  + ]:          1 :     if (fCheckPOW && fCheckMerkleRoot)
    3687                 :          1 :         block.fChecked = true;
    3688                 :            : 
    3689                 :          1 :     return true;
    3690                 :          1 : }
    3691                 :            : 
    3692                 :          0 : void ChainstateManager::UpdateUncommittedBlockStructures(CBlock& block, const CBlockIndex* pindexPrev) const
    3693                 :            : {
    3694                 :          0 :     int commitpos = GetWitnessCommitmentIndex(block);
    3695   [ #  #  #  #  :          0 :     static const std::vector<unsigned char> nonce(32, 0x00);
                   #  # ]
    3696   [ #  #  #  #  :          0 :     if (commitpos != NO_WITNESS_COMMITMENT && DeploymentActiveAfter(pindexPrev, *this, Consensus::DEPLOYMENT_SEGWIT) && !block.vtx[0]->HasWitness()) {
                   #  # ]
    3697                 :          0 :         CMutableTransaction tx(*block.vtx[0]);
    3698         [ #  # ]:          0 :         tx.vin[0].scriptWitness.stack.resize(1);
    3699         [ #  # ]:          0 :         tx.vin[0].scriptWitness.stack[0] = nonce;
    3700         [ #  # ]:          0 :         block.vtx[0] = MakeTransactionRef(std::move(tx));
    3701                 :          0 :     }
    3702                 :          0 : }
    3703                 :            : 
    3704                 :          0 : std::vector<unsigned char> ChainstateManager::GenerateCoinbaseCommitment(CBlock& block, const CBlockIndex* pindexPrev) const
    3705                 :            : {
    3706                 :          0 :     std::vector<unsigned char> commitment;
    3707         [ #  # ]:          0 :     int commitpos = GetWitnessCommitmentIndex(block);
    3708         [ #  # ]:          0 :     std::vector<unsigned char> ret(32, 0x00);
    3709         [ #  # ]:          0 :     if (commitpos == NO_WITNESS_COMMITMENT) {
    3710         [ #  # ]:          0 :         uint256 witnessroot = BlockWitnessMerkleRoot(block, nullptr);
    3711   [ #  #  #  #  :          0 :         CHash256().Write(witnessroot).Write(ret).Finalize(witnessroot);
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    3712         [ #  # ]:          0 :         CTxOut out;
    3713                 :          0 :         out.nValue = 0;
    3714         [ #  # ]:          0 :         out.scriptPubKey.resize(MINIMUM_WITNESS_COMMITMENT);
    3715         [ #  # ]:          0 :         out.scriptPubKey[0] = OP_RETURN;
    3716         [ #  # ]:          0 :         out.scriptPubKey[1] = 0x24;
    3717         [ #  # ]:          0 :         out.scriptPubKey[2] = 0xaa;
    3718         [ #  # ]:          0 :         out.scriptPubKey[3] = 0x21;
    3719         [ #  # ]:          0 :         out.scriptPubKey[4] = 0xa9;
    3720         [ #  # ]:          0 :         out.scriptPubKey[5] = 0xed;
    3721   [ #  #  #  # ]:          0 :         memcpy(&out.scriptPubKey[6], witnessroot.begin(), 32);
    3722   [ #  #  #  #  :          0 :         commitment = std::vector<unsigned char>(out.scriptPubKey.begin(), out.scriptPubKey.end());
                   #  # ]
    3723         [ #  # ]:          0 :         CMutableTransaction tx(*block.vtx[0]);
    3724         [ #  # ]:          0 :         tx.vout.push_back(out);
    3725         [ #  # ]:          0 :         block.vtx[0] = MakeTransactionRef(std::move(tx));
    3726                 :          0 :     }
    3727         [ #  # ]:          0 :     UpdateUncommittedBlockStructures(block, pindexPrev);
    3728                 :          0 :     return commitment;
    3729         [ #  # ]:          0 : }
    3730                 :            : 
    3731                 :          0 : bool HasValidProofOfWork(const std::vector<CBlockHeader>& headers, const Consensus::Params& consensusParams)
    3732                 :            : {
    3733                 :          0 :     return std::all_of(headers.cbegin(), headers.cend(),
    3734                 :          0 :             [&](const auto& header) { return CheckProofOfWork(header.GetHash(), header.nBits, consensusParams);});
    3735                 :            : }
    3736                 :            : 
    3737                 :          0 : arith_uint256 CalculateHeadersWork(const std::vector<CBlockHeader>& headers)
    3738                 :            : {
    3739                 :          0 :     arith_uint256 total_work{0};
    3740         [ #  # ]:          0 :     for (const CBlockHeader& header : headers) {
    3741                 :          0 :         CBlockIndex dummy(header);
    3742                 :          0 :         total_work += GetBlockProof(dummy);
    3743                 :            :     }
    3744                 :          0 :     return total_work;
    3745                 :            : }
    3746                 :            : 
    3747                 :            : /** Context-dependent validity checks.
    3748                 :            :  *  By "context", we mean only the previous block headers, but not the UTXO
    3749                 :            :  *  set; UTXO-related validity checks are done in ConnectBlock().
    3750                 :            :  *  NOTE: This function is not currently invoked by ConnectBlock(), so we
    3751                 :            :  *  should consider upgrade issues if we change which consensus rules are
    3752                 :            :  *  enforced in this function (eg by adding a new consensus rule). See comment
    3753                 :            :  *  in ConnectBlock().
    3754                 :            :  *  Note that -reindex-chainstate skips the validation that happens here!
    3755                 :            :  */
    3756                 :          0 : static bool ContextualCheckBlockHeader(const CBlockHeader& block, BlockValidationState& state, BlockManager& blockman, const ChainstateManager& chainman, const CBlockIndex* pindexPrev, NodeClock::time_point now) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
    3757                 :            : {
    3758                 :          0 :     AssertLockHeld(::cs_main);
    3759         [ #  # ]:          0 :     assert(pindexPrev != nullptr);
    3760                 :          0 :     const int nHeight = pindexPrev->nHeight + 1;
    3761                 :            : 
    3762                 :            :     // Check proof of work
    3763                 :          0 :     const Consensus::Params& consensusParams = chainman.GetConsensus();
    3764         [ #  # ]:          0 :     if (block.nBits != GetNextWorkRequired(pindexPrev, &block, consensusParams))
    3765   [ #  #  #  #  :          0 :         return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "bad-diffbits", "incorrect proof of work");
                   #  # ]
    3766                 :            : 
    3767                 :            :     // Check against checkpoints
    3768         [ #  # ]:          0 :     if (chainman.m_options.checkpoints_enabled) {
    3769                 :            :         // Don't accept any forks from the main chain prior to last checkpoint.
    3770                 :            :         // GetLastCheckpoint finds the last checkpoint in MapCheckpoints that's in our
    3771                 :            :         // BlockIndex().
    3772                 :          0 :         const CBlockIndex* pcheckpoint = blockman.GetLastCheckpoint(chainman.GetParams().Checkpoints());
    3773   [ #  #  #  # ]:          0 :         if (pcheckpoint && nHeight < pcheckpoint->nHeight) {
    3774   [ #  #  #  #  :          0 :             LogPrintf("ERROR: %s: forked chain older than last checkpoint (height %d)\n", __func__, nHeight);
                   #  # ]
    3775   [ #  #  #  #  :          0 :             return state.Invalid(BlockValidationResult::BLOCK_CHECKPOINT, "bad-fork-prior-to-checkpoint");
                   #  # ]
    3776                 :            :         }
    3777                 :          0 :     }
    3778                 :            : 
    3779                 :            :     // Check timestamp against prev
    3780         [ #  # ]:          0 :     if (block.GetBlockTime() <= pindexPrev->GetMedianTimePast())
    3781   [ #  #  #  #  :          0 :         return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "time-too-old", "block's timestamp is too early");
                   #  # ]
    3782                 :            : 
    3783                 :            :     // Check timestamp
    3784         [ #  # ]:          0 :     if (block.Time() > now + std::chrono::seconds{MAX_FUTURE_BLOCK_TIME}) {
    3785   [ #  #  #  #  :          0 :         return state.Invalid(BlockValidationResult::BLOCK_TIME_FUTURE, "time-too-new", "block timestamp too far in the future");
                   #  # ]
    3786                 :            :     }
    3787                 :            : 
    3788                 :            :     // Reject blocks with outdated version
    3789   [ #  #  #  # ]:          0 :     if ((block.nVersion < 2 && DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_HEIGHTINCB)) ||
    3790         [ #  # ]:          0 :         (block.nVersion < 3 && DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_DERSIG)) ||
    3791         [ #  # ]:          0 :         (block.nVersion < 4 && DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_CLTV))) {
    3792         [ #  # ]:          0 :             return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, strprintf("bad-version(0x%08x)", block.nVersion),
    3793         [ #  # ]:          0 :                                  strprintf("rejected nVersion=0x%08x block", block.nVersion));
    3794                 :            :     }
    3795                 :            : 
    3796                 :          0 :     return true;
    3797                 :          0 : }
    3798                 :            : 
    3799                 :            : /** NOTE: This function is not currently invoked by ConnectBlock(), so we
    3800                 :            :  *  should consider upgrade issues if we change which consensus rules are
    3801                 :            :  *  enforced in this function (eg by adding a new consensus rule). See comment
    3802                 :            :  *  in ConnectBlock().
    3803                 :            :  *  Note that -reindex-chainstate skips the validation that happens here!
    3804                 :            :  */
    3805                 :          0 : static bool ContextualCheckBlock(const CBlock& block, BlockValidationState& state, const ChainstateManager& chainman, const CBlockIndex* pindexPrev)
    3806                 :            : {
    3807         [ #  # ]:          0 :     const int nHeight = pindexPrev == nullptr ? 0 : pindexPrev->nHeight + 1;
    3808                 :            : 
    3809                 :            :     // Enforce BIP113 (Median Time Past).
    3810                 :          0 :     bool enforce_locktime_median_time_past{false};
    3811         [ #  # ]:          0 :     if (DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_CSV)) {
    3812         [ #  # ]:          0 :         assert(pindexPrev != nullptr);
    3813                 :          0 :         enforce_locktime_median_time_past = true;
    3814                 :          0 :     }
    3815                 :            : 
    3816         [ #  # ]:          0 :     const int64_t nLockTimeCutoff{enforce_locktime_median_time_past ?
    3817                 :          0 :                                       pindexPrev->GetMedianTimePast() :
    3818                 :          0 :                                       block.GetBlockTime()};
    3819                 :            : 
    3820                 :            :     // Check that all transactions are finalized
    3821         [ #  # ]:          0 :     for (const auto& tx : block.vtx) {
    3822         [ #  # ]:          0 :         if (!IsFinalTx(*tx, nHeight, nLockTimeCutoff)) {
    3823   [ #  #  #  #  :          0 :             return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-txns-nonfinal", "non-final transaction");
                   #  # ]
    3824                 :            :         }
    3825                 :            :     }
    3826                 :            : 
    3827                 :            :     // Enforce rule that the coinbase starts with serialized block height
    3828         [ #  # ]:          0 :     if (DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_HEIGHTINCB))
    3829                 :            :     {
    3830   [ #  #  #  # ]:          0 :         CScript expect = CScript() << nHeight;
    3831   [ #  #  #  #  :          0 :         if (block.vtx[0]->vin[0].scriptSig.size() < expect.size() ||
             #  #  #  # ]
    3832   [ #  #  #  #  :          0 :             !std::equal(expect.begin(), expect.end(), block.vtx[0]->vin[0].scriptSig.begin())) {
             #  #  #  # ]
    3833   [ #  #  #  #  :          0 :             return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-cb-height", "block height mismatch in coinbase");
                   #  # ]
    3834                 :            :         }
    3835      [ #  #  # ]:          0 :     }
    3836                 :            : 
    3837                 :            :     // Validation for witness commitments.
    3838                 :            :     // * We compute the witness hash (which is the hash including witnesses) of all the block's transactions, except the
    3839                 :            :     //   coinbase (where 0x0000....0000 is used instead).
    3840                 :            :     // * The coinbase scriptWitness is a stack of a single 32-byte vector, containing a witness reserved value (unconstrained).
    3841                 :            :     // * We build a merkle tree with all those witness hashes as leaves (similar to the hashMerkleRoot in the block header).
    3842                 :            :     // * There must be at least one output whose scriptPubKey is a single 36-byte push, the first 4 bytes of which are
    3843                 :            :     //   {0xaa, 0x21, 0xa9, 0xed}, and the following 32 bytes are SHA256^2(witness root, witness reserved value). In case there are
    3844                 :            :     //   multiple, the last one is used.
    3845                 :          0 :     bool fHaveWitness = false;
    3846         [ #  # ]:          0 :     if (DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_SEGWIT)) {
    3847                 :          0 :         int commitpos = GetWitnessCommitmentIndex(block);
    3848         [ #  # ]:          0 :         if (commitpos != NO_WITNESS_COMMITMENT) {
    3849                 :          0 :             bool malleated = false;
    3850                 :          0 :             uint256 hashWitness = BlockWitnessMerkleRoot(block, &malleated);
    3851                 :            :             // The malleation check is ignored; as the transaction tree itself
    3852                 :            :             // already does not permit it, it is impossible to trigger in the
    3853                 :            :             // witness tree.
    3854   [ #  #  #  # ]:          0 :             if (block.vtx[0]->vin[0].scriptWitness.stack.size() != 1 || block.vtx[0]->vin[0].scriptWitness.stack[0].size() != 32) {
    3855   [ #  #  #  #  :          0 :                 return state.Invalid(BlockValidationResult::BLOCK_MUTATED, "bad-witness-nonce-size", strprintf("%s : invalid witness reserved value size", __func__));
                   #  # ]
    3856                 :            :             }
    3857                 :          0 :             CHash256().Write(hashWitness).Write(block.vtx[0]->vin[0].scriptWitness.stack[0]).Finalize(hashWitness);
    3858         [ #  # ]:          0 :             if (memcmp(hashWitness.begin(), &block.vtx[0]->vout[commitpos].scriptPubKey[6], 32)) {
    3859   [ #  #  #  #  :          0 :                 return state.Invalid(BlockValidationResult::BLOCK_MUTATED, "bad-witness-merkle-match", strprintf("%s : witness merkle commitment mismatch", __func__));
                   #  # ]
    3860                 :            :             }
    3861                 :          0 :             fHaveWitness = true;
    3862                 :          0 :         }
    3863                 :          0 :     }
    3864                 :            : 
    3865                 :            :     // No witness data is allowed in blocks that don't commit to witness data, as this would otherwise leave room for spam
    3866         [ #  # ]:          0 :     if (!fHaveWitness) {
    3867         [ #  # ]:          0 :       for (const auto& tx : block.vtx) {
    3868         [ #  # ]:          0 :             if (tx->HasWitness()) {
    3869   [ #  #  #  #  :          0 :                 return state.Invalid(BlockValidationResult::BLOCK_MUTATED, "unexpected-witness", strprintf("%s : unexpected witness data found", __func__));
                   #  # ]
    3870                 :            :             }
    3871                 :            :         }
    3872                 :          0 :     }
    3873                 :            : 
    3874                 :            :     // After the coinbase witness reserved value and commitment are verified,
    3875                 :            :     // we can check if the block weight passes (before we've checked the
    3876                 :            :     // coinbase witness, it would be possible for the weight to be too
    3877                 :            :     // large by filling up the coinbase witness, which doesn't change
    3878                 :            :     // the block hash, so we couldn't mark the block as permanently
    3879                 :            :     // failed).
    3880         [ #  # ]:          0 :     if (GetBlockWeight(block) > MAX_BLOCK_WEIGHT) {
    3881   [ #  #  #  #  :          0 :         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-blk-weight", strprintf("%s : weight limit failed", __func__));
                   #  # ]
    3882                 :            :     }
    3883                 :            : 
    3884                 :          0 :     return true;
    3885                 :          0 : }
    3886                 :            : 
    3887                 :          0 : bool ChainstateManager::AcceptBlockHeader(const CBlockHeader& block, BlockValidationState& state, CBlockIndex** ppindex, bool min_pow_checked)
    3888                 :            : {
    3889                 :          0 :     AssertLockHeld(cs_main);
    3890                 :            : 
    3891                 :            :     // Check for duplicate
    3892                 :          0 :     uint256 hash = block.GetHash();
    3893                 :          0 :     BlockMap::iterator miSelf{m_blockman.m_block_index.find(hash)};
    3894         [ #  # ]:          0 :     if (hash != GetConsensus().hashGenesisBlock) {
    3895         [ #  # ]:          0 :         if (miSelf != m_blockman.m_block_index.end()) {
    3896                 :            :             // Block header is already known.
    3897                 :          0 :             CBlockIndex* pindex = &(miSelf->second);
    3898         [ #  # ]:          0 :             if (ppindex)
    3899                 :          0 :                 *ppindex = pindex;
    3900         [ #  # ]:          0 :             if (pindex->nStatus & BLOCK_FAILED_MASK) {
    3901   [ #  #  #  #  :          0 :                 LogPrint(BCLog::VALIDATION, "%s: block %s is marked invalid\n", __func__, hash.ToString());
          #  #  #  #  #  
                      # ]
    3902   [ #  #  #  #  :          0 :                 return state.Invalid(BlockValidationResult::BLOCK_CACHED_INVALID, "duplicate");
                   #  # ]
    3903                 :            :             }
    3904                 :          0 :             return true;
    3905                 :            :         }
    3906                 :            : 
    3907         [ #  # ]:          0 :         if (!CheckBlockHeader(block, state, GetConsensus())) {
    3908   [ #  #  #  #  :          0 :             LogPrint(BCLog::VALIDATION, "%s: Consensus::CheckBlockHeader: %s, %s\n", __func__, hash.ToString(), state.ToString());
          #  #  #  #  #  
                #  #  # ]
    3909                 :          0 :             return false;
    3910                 :            :         }
    3911                 :            : 
    3912                 :            :         // Get prev block index
    3913                 :          0 :         CBlockIndex* pindexPrev = nullptr;
    3914                 :          0 :         BlockMap::iterator mi{m_blockman.m_block_index.find(block.hashPrevBlock)};
    3915         [ #  # ]:          0 :         if (mi == m_blockman.m_block_index.end()) {
    3916   [ #  #  #  #  :          0 :             LogPrint(BCLog::VALIDATION, "header %s has prev block not found: %s\n", hash.ToString(), block.hashPrevBlock.ToString());
          #  #  #  #  #  
                #  #  # ]
    3917   [ #  #  #  #  :          0 :             return state.Invalid(BlockValidationResult::BLOCK_MISSING_PREV, "prev-blk-not-found");
                   #  # ]
    3918                 :            :         }
    3919                 :          0 :         pindexPrev = &((*mi).second);
    3920         [ #  # ]:          0 :         if (pindexPrev->nStatus & BLOCK_FAILED_MASK) {
    3921   [ #  #  #  #  :          0 :             LogPrint(BCLog::VALIDATION, "header %s has prev block invalid: %s\n", hash.ToString(), block.hashPrevBlock.ToString());
          #  #  #  #  #  
                #  #  # ]
    3922   [ #  #  #  #  :          0 :             return state.Invalid(BlockValidationResult::BLOCK_INVALID_PREV, "bad-prevblk");
                   #  # ]
    3923                 :            :         }
    3924         [ #  # ]:          0 :         if (!ContextualCheckBlockHeader(block, state, m_blockman, *this, pindexPrev, m_options.adjusted_time_callback())) {
    3925   [ #  #  #  #  :          0 :             LogPrint(BCLog::VALIDATION, "%s: Consensus::ContextualCheckBlockHeader: %s, %s\n", __func__, hash.ToString(), state.ToString());
          #  #  #  #  #  
                #  #  # ]
    3926                 :          0 :             return false;
    3927                 :            :         }
    3928                 :            : 
    3929                 :            :         /* Determine if this block descends from any block which has been found
    3930                 :            :          * invalid (m_failed_blocks), then mark pindexPrev and any blocks between
    3931                 :            :          * them as failed. For example:
    3932                 :            :          *
    3933                 :            :          *                D3
    3934                 :            :          *              /
    3935                 :            :          *      B2 - C2
    3936                 :            :          *    /         \
    3937                 :            :          *  A             D2 - E2 - F2
    3938                 :            :          *    \
    3939                 :            :          *      B1 - C1 - D1 - E1
    3940                 :            :          *
    3941                 :            :          * In the case that we attempted to reorg from E1 to F2, only to find
    3942                 :            :          * C2 to be invalid, we would mark D2, E2, and F2 as BLOCK_FAILED_CHILD
    3943                 :            :          * but NOT D3 (it was not in any of our candidate sets at the time).
    3944                 :            :          *
    3945                 :            :          * In any case D3 will also be marked as BLOCK_FAILED_CHILD at restart
    3946                 :            :          * in LoadBlockIndex.
    3947                 :            :          */
    3948         [ #  # ]:          0 :         if (!pindexPrev->IsValid(BLOCK_VALID_SCRIPTS)) {
    3949                 :            :             // The above does not mean "invalid": it checks if the previous block
    3950                 :            :             // hasn't been validated up to BLOCK_VALID_SCRIPTS. This is a performance
    3951                 :            :             // optimization, in the common case of adding a new block to the tip,
    3952                 :            :             // we don't need to iterate over the failed blocks list.
    3953         [ #  # ]:          0 :             for (const CBlockIndex* failedit : m_failed_blocks) {
    3954         [ #  # ]:          0 :                 if (pindexPrev->GetAncestor(failedit->nHeight) == failedit) {
    3955         [ #  # ]:          0 :                     assert(failedit->nStatus & BLOCK_FAILED_VALID);
    3956                 :          0 :                     CBlockIndex* invalid_walk = pindexPrev;
    3957         [ #  # ]:          0 :                     while (invalid_walk != failedit) {
    3958                 :          0 :                         invalid_walk->nStatus |= BLOCK_FAILED_CHILD;
    3959                 :          0 :                         m_blockman.m_dirty_blockindex.insert(invalid_walk);
    3960                 :          0 :                         invalid_walk = invalid_walk->pprev;
    3961                 :            :                     }
    3962   [ #  #  #  #  :          0 :                     LogPrint(BCLog::VALIDATION, "header %s has prev block invalid: %s\n", hash.ToString(), block.hashPrevBlock.ToString());
          #  #  #  #  #  
                #  #  # ]
    3963   [ #  #  #  #  :          0 :                     return state.Invalid(BlockValidationResult::BLOCK_INVALID_PREV, "bad-prevblk");
                   #  # ]
    3964                 :            :                 }
    3965                 :            :             }
    3966                 :          0 :         }
    3967                 :          0 :     }
    3968         [ #  # ]:          0 :     if (!min_pow_checked) {
    3969   [ #  #  #  #  :          0 :         LogPrint(BCLog::VALIDATION, "%s: not adding new block header %s, missing anti-dos proof-of-work validation\n", __func__, hash.ToString());
          #  #  #  #  #  
                      # ]
    3970   [ #  #  #  #  :          0 :         return state.Invalid(BlockValidationResult::BLOCK_HEADER_LOW_WORK, "too-little-chainwork");
                   #  # ]
    3971                 :            :     }
    3972                 :          0 :     CBlockIndex* pindex{m_blockman.AddToBlockIndex(block, m_best_header)};
    3973                 :            : 
    3974         [ #  # ]:          0 :     if (ppindex)
    3975                 :          0 :         *ppindex = pindex;
    3976                 :            : 
    3977                 :            :     // Since this is the earliest point at which we have determined that a
    3978                 :            :     // header is both new and valid, log here.
    3979                 :            :     //
    3980                 :            :     // These messages are valuable for detecting potential selfish mining behavior;
    3981                 :            :     // if multiple displacing headers are seen near simultaneously across many
    3982                 :            :     // nodes in the network, this might be an indication of selfish mining. Having
    3983                 :            :     // this log by default when not in IBD ensures broad availability of this data
    3984                 :            :     // in case investigation is merited.
    3985         [ #  # ]:          0 :     const auto msg = strprintf(
    3986                 :          0 :         "Saw new header hash=%s height=%d", hash.ToString(), pindex->nHeight);
    3987                 :            : 
    3988   [ #  #  #  # ]:          0 :     if (IsInitialBlockDownload()) {
    3989   [ #  #  #  #  :          0 :         LogPrintLevel(BCLog::VALIDATION, BCLog::Level::Debug, "%s\n", msg);
          #  #  #  #  #  
                      # ]
    3990                 :          0 :     } else {
    3991   [ #  #  #  #  :          0 :         LogPrintf("%s\n", msg);
                   #  # ]
    3992                 :            :     }
    3993                 :            : 
    3994                 :          0 :     return true;
    3995                 :          0 : }
    3996                 :            : 
    3997                 :            : // Exposed wrapper for AcceptBlockHeader
    3998                 :          0 : bool ChainstateManager::ProcessNewBlockHeaders(const std::vector<CBlockHeader>& headers, bool min_pow_checked, BlockValidationState& state, const CBlockIndex** ppindex)
    3999                 :            : {
    4000                 :          0 :     AssertLockNotHeld(cs_main);
    4001                 :            :     {
    4002                 :          0 :         LOCK(cs_main);
    4003         [ #  # ]:          0 :         for (const CBlockHeader& header : headers) {
    4004                 :          0 :             CBlockIndex *pindex = nullptr; // Use a temp pindex instead of ppindex to avoid a const_cast
    4005         [ #  # ]:          0 :             bool accepted{AcceptBlockHeader(header, state, &pindex, min_pow_checked)};
    4006         [ #  # ]:          0 :             CheckBlockIndex();
    4007                 :            : 
    4008         [ #  # ]:          0 :             if (!accepted) {
    4009                 :          0 :                 return false;
    4010                 :            :             }
    4011         [ #  # ]:          0 :             if (ppindex) {
    4012                 :          0 :                 *ppindex = pindex;
    4013                 :          0 :             }
    4014                 :            :         }
    4015      [ #  #  # ]:          0 :     }
    4016         [ #  # ]:          0 :     if (NotifyHeaderTip(*this)) {
    4017   [ #  #  #  #  :          0 :         if (IsInitialBlockDownload() && ppindex && *ppindex) {
                   #  # ]
    4018                 :          0 :             const CBlockIndex& last_accepted{**ppindex};
    4019                 :          0 :             const int64_t blocks_left{(GetTime() - last_accepted.GetBlockTime()) / GetConsensus().nPowTargetSpacing};
    4020                 :          0 :             const double progress{100.0 * last_accepted.nHeight / (last_accepted.nHeight + blocks_left)};
    4021   [ #  #  #  #  :          0 :             LogPrintf("Synchronizing blockheaders, height: %d (~%.2f%%)\n", last_accepted.nHeight, progress);
                   #  # ]
    4022                 :          0 :         }
    4023                 :          0 :     }
    4024                 :          0 :     return true;
    4025                 :          0 : }
    4026                 :            : 
    4027                 :          0 : void ChainstateManager::ReportHeadersPresync(const arith_uint256& work, int64_t height, int64_t timestamp)
    4028                 :            : {
    4029                 :          0 :     AssertLockNotHeld(cs_main);
    4030                 :            :     {
    4031                 :          0 :         LOCK(cs_main);
    4032                 :            :         // Don't report headers presync progress if we already have a post-minchainwork header chain.
    4033                 :            :         // This means we lose reporting for potentially legitimate, but unlikely, deep reorgs, but
    4034                 :            :         // prevent attackers that spam low-work headers from filling our logs.
    4035   [ #  #  #  #  :          0 :         if (m_best_header->nChainWork >= UintToArith256(GetConsensus().nMinimumChainWork)) return;
             #  #  #  # ]
    4036                 :            :         // Rate limit headers presync updates to 4 per second, as these are not subject to DoS
    4037                 :            :         // protection.
    4038                 :          0 :         auto now = std::chrono::steady_clock::now();
    4039   [ #  #  #  #  :          0 :         if (now < m_last_presync_update + std::chrono::milliseconds{250}) return;
             #  #  #  # ]
    4040                 :          0 :         m_last_presync_update = now;
    4041      [ #  #  # ]:          0 :     }
    4042                 :          0 :     bool initial_download = IsInitialBlockDownload();
    4043                 :          0 :     GetNotifications().headerTip(GetSynchronizationState(initial_download), height, timestamp, /*presync=*/true);
    4044         [ #  # ]:          0 :     if (initial_download) {
    4045                 :          0 :         const int64_t blocks_left{(GetTime() - timestamp) / GetConsensus().nPowTargetSpacing};
    4046                 :          0 :         const double progress{100.0 * height / (height + blocks_left)};
    4047   [ #  #  #  #  :          0 :         LogPrintf("Pre-synchronizing blockheaders, height: %d (~%.2f%%)\n", height, progress);
                   #  # ]
    4048                 :          0 :     }
    4049                 :          0 : }
    4050                 :            : 
    4051                 :            : /** Store block on disk. If dbp is non-nullptr, the file is known to already reside on disk */
    4052                 :          0 : bool ChainstateManager::AcceptBlock(const std::shared_ptr<const CBlock>& pblock, BlockValidationState& state, CBlockIndex** ppindex, bool fRequested, const FlatFilePos* dbp, bool* fNewBlock, bool min_pow_checked)
    4053                 :            : {
    4054                 :          0 :     const CBlock& block = *pblock;
    4055                 :            : 
    4056                 :          0 :     if (fNewBlock) *fNewBlock = false;
    4057                 :          0 :     AssertLockHeld(cs_main);
    4058                 :            : 
    4059                 :          0 :     CBlockIndex *pindexDummy = nullptr;
    4060         [ #  # ]:          0 :     CBlockIndex *&pindex = ppindex ? *ppindex : pindexDummy;
    4061                 :            : 
    4062                 :          0 :     bool accepted_header{AcceptBlockHeader(block, state, &pindex, min_pow_checked)};
    4063                 :          0 :     CheckBlockIndex();
    4064                 :            : 
    4065         [ #  # ]:          0 :     if (!accepted_header)
    4066                 :          0 :         return false;
    4067                 :            : 
    4068                 :            :     // Check all requested blocks that we do not already have for validity and
    4069                 :            :     // save them to disk. Skip processing of unrequested blocks as an anti-DoS
    4070                 :            :     // measure, unless the blocks have more work than the active chain tip, and
    4071                 :            :     // aren't too far ahead of it, so are likely to be attached soon.
    4072                 :          0 :     bool fAlreadyHave = pindex->nStatus & BLOCK_HAVE_DATA;
    4073         [ #  # ]:          0 :     bool fHasMoreOrSameWork = (ActiveTip() ? pindex->nChainWork >= ActiveTip()->nChainWork : true);
    4074                 :            :     // Blocks that are too out-of-order needlessly limit the effectiveness of
    4075                 :            :     // pruning, because pruning will not delete block files that contain any
    4076                 :            :     // blocks which are too close in height to the tip.  Apply this test
    4077                 :            :     // regardless of whether pruning is enabled; it should generally be safe to
    4078                 :            :     // not process unrequested blocks.
    4079                 :          0 :     bool fTooFarAhead{pindex->nHeight > ActiveHeight() + int(MIN_BLOCKS_TO_KEEP)};
    4080                 :            : 
    4081                 :            :     // TODO: Decouple this function from the block download logic by removing fRequested
    4082                 :            :     // This requires some new chain data structure to efficiently look up if a
    4083                 :            :     // block is in a chain leading to a candidate for best tip, despite not
    4084                 :            :     // being such a candidate itself.
    4085                 :            :     // Note that this would break the getblockfrompeer RPC
    4086                 :            : 
    4087                 :            :     // TODO: deal better with return value and error conditions for duplicate
    4088                 :            :     // and unrequested blocks.
    4089         [ #  # ]:          0 :     if (fAlreadyHave) return true;
    4090         [ #  # ]:          0 :     if (!fRequested) {  // If we didn't ask for it:
    4091         [ #  # ]:          0 :         if (pindex->nTx != 0) return true;    // This is a previously-processed block that was pruned
    4092         [ #  # ]:          0 :         if (!fHasMoreOrSameWork) return true; // Don't process less-work chains
    4093         [ #  # ]:          0 :         if (fTooFarAhead) return true;        // Block height is too high
    4094                 :            : 
    4095                 :            :         // Protect against DoS attacks from low-work chains.
    4096                 :            :         // If our tip is behind, a peer could try to send us
    4097                 :            :         // low-work blocks on a fake chain that we would never
    4098                 :            :         // request; don't process these.
    4099         [ #  # ]:          0 :         if (pindex->nChainWork < MinimumChainWork()) return true;
    4100                 :          0 :     }
    4101                 :            : 
    4102                 :          0 :     const CChainParams& params{GetParams()};
    4103                 :            : 
    4104   [ #  #  #  # ]:          0 :     if (!CheckBlock(block, state, params.GetConsensus()) ||
    4105                 :          0 :         !ContextualCheckBlock(block, state, *this, pindex->pprev)) {
    4106   [ #  #  #  # ]:          0 :         if (state.IsInvalid() && state.GetResult() != BlockValidationResult::BLOCK_MUTATED) {
    4107                 :          0 :             pindex->nStatus |= BLOCK_FAILED_VALID;
    4108                 :          0 :             m_blockman.m_dirty_blockindex.insert(pindex);
    4109                 :          0 :         }
    4110         [ #  # ]:          0 :         return error("%s: %s", __func__, state.ToString());
    4111                 :            :     }
    4112                 :            : 
    4113                 :            :     // Header is valid/has work, merkle tree and segwit merkle tree are good...RELAY NOW
    4114                 :            :     // (but if it does not build on our best tip, let the SendMessages loop relay it)
    4115   [ #  #  #  # ]:          0 :     if (!IsInitialBlockDownload() && ActiveTip() == pindex->pprev)
    4116                 :          0 :         GetMainSignals().NewPoWValidBlock(pindex, pblock);
    4117                 :            : 
    4118                 :            :     // Write block to history file
    4119         [ #  # ]:          0 :     if (fNewBlock) *fNewBlock = true;
    4120                 :            :     try {
    4121         [ #  # ]:          0 :         FlatFilePos blockPos{m_blockman.SaveBlockToDisk(block, pindex->nHeight, dbp)};
    4122   [ #  #  #  # ]:          0 :         if (blockPos.IsNull()) {
    4123   [ #  #  #  # ]:          0 :             state.Error(strprintf("%s: Failed to find position to write new block to disk", __func__));
    4124                 :          0 :             return false;
    4125                 :            :         }
    4126         [ #  # ]:          0 :         ReceivedBlockTransactions(block, pindex, blockPos);
    4127         [ #  # ]:          0 :     } catch (const std::runtime_error& e) {
    4128   [ #  #  #  #  :          0 :         return FatalError(GetNotifications(), state, std::string("System error: ") + e.what());
             #  #  #  # ]
    4129         [ #  # ]:          0 :     }
    4130                 :            : 
    4131                 :            :     // TODO: FlushStateToDisk() handles flushing of both block and chainstate
    4132                 :            :     // data, so we should move this to ChainstateManager so that we can be more
    4133                 :            :     // intelligent about how we flush.
    4134                 :            :     // For now, since FlushStateMode::NONE is used, all that can happen is that
    4135                 :            :     // the block files may be pruned, so we can just call this on one
    4136                 :            :     // chainstate (particularly if we haven't implemented pruning with
    4137                 :            :     // background validation yet).
    4138                 :          0 :     ActiveChainstate().FlushStateToDisk(state, FlushStateMode::NONE);
    4139                 :            : 
    4140                 :          0 :     CheckBlockIndex();
    4141                 :            : 
    4142                 :          0 :     return true;
    4143                 :          0 : }
    4144                 :            : 
    4145                 :          0 : bool ChainstateManager::ProcessNewBlock(const std::shared_ptr<const CBlock>& block, bool force_processing, bool min_pow_checked, bool* new_block)
    4146                 :            : {
    4147                 :          0 :     AssertLockNotHeld(cs_main);
    4148                 :            : 
    4149                 :            :     {
    4150                 :          0 :         CBlockIndex *pindex = nullptr;
    4151         [ #  # ]:          0 :         if (new_block) *new_block = false;
    4152                 :          0 :         BlockValidationState state;
    4153                 :            : 
    4154                 :            :         // CheckBlock() does not support multi-threaded block validation because CBlock::fChecked can cause data race.
    4155                 :            :         // Therefore, the following critical section must include the CheckBlock() call as well.
    4156   [ #  #  #  # ]:          0 :         LOCK(cs_main);
    4157                 :            : 
    4158                 :            :         // Skipping AcceptBlock() for CheckBlock() failures means that we will never mark a block as invalid if
    4159                 :            :         // CheckBlock() fails.  This is protective against consensus failure if there are any unknown forms of block
    4160                 :            :         // malleability that cause CheckBlock() to fail; see e.g. CVE-2012-2459 and
    4161                 :            :         // https://lists.linuxfoundation.org/pipermail/bitcoin-dev/2019-February/016697.html.  Because CheckBlock() is
    4162                 :            :         // not very expensive, the anti-DoS benefits of caching failure (of a definitely-invalid block) are not substantial.
    4163   [ #  #  #  # ]:          0 :         bool ret = CheckBlock(*block, state, GetConsensus());
    4164         [ #  # ]:          0 :         if (ret) {
    4165                 :            :             // Store to disk
    4166         [ #  # ]:          0 :             ret = AcceptBlock(block, state, &pindex, force_processing, nullptr, new_block, min_pow_checked);
    4167                 :          0 :         }
    4168         [ #  # ]:          0 :         if (!ret) {
    4169   [ #  #  #  # ]:          0 :             GetMainSignals().BlockChecked(*block, state);
    4170   [ #  #  #  # ]:          0 :             return error("%s: AcceptBlock FAILED (%s)", __func__, state.ToString());
    4171                 :            :         }
    4172      [ #  #  # ]:          0 :     }
    4173                 :            : 
    4174                 :          0 :     NotifyHeaderTip(*this);
    4175                 :            : 
    4176                 :          0 :     BlockValidationState state; // Only used to report errors, not invalidity - ignore it
    4177   [ #  #  #  #  :          0 :     if (!ActiveChainstate().ActivateBestChain(state, block)) {
                   #  # ]
    4178   [ #  #  #  # ]:          0 :         return error("%s: ActivateBestChain failed (%s)", __func__, state.ToString());
    4179                 :            :     }
    4180                 :            : 
    4181   [ #  #  #  #  :          0 :     Chainstate* bg_chain{WITH_LOCK(cs_main, return BackgroundSyncInProgress() ? m_ibd_chainstate.get() : nullptr)};
             #  #  #  # ]
    4182                 :          0 :     BlockValidationState bg_state;
    4183   [ #  #  #  #  :          0 :     if (bg_chain && !bg_chain->ActivateBestChain(bg_state, block)) {
          #  #  #  #  #  
                      # ]
    4184   [ #  #  #  # ]:          0 :         return error("%s: [background] ActivateBestChain failed (%s)", __func__, bg_state.ToString());
    4185                 :            :      }
    4186                 :            : 
    4187                 :          0 :     return true;
    4188                 :          0 : }
    4189                 :            : 
    4190                 :          0 : MempoolAcceptResult ChainstateManager::ProcessTransaction(const CTransactionRef& tx, bool test_accept)
    4191                 :            : {
    4192                 :          0 :     AssertLockHeld(cs_main);
    4193                 :          0 :     Chainstate& active_chainstate = ActiveChainstate();
    4194         [ #  # ]:          0 :     if (!active_chainstate.GetMempool()) {
    4195                 :          0 :         TxValidationState state;
    4196   [ #  #  #  #  :          0 :         state.Invalid(TxValidationResult::TX_NO_MEMPOOL, "no-mempool");
                   #  # ]
    4197   [ #  #  #  # ]:          0 :         return MempoolAcceptResult::Failure(state);
    4198                 :          0 :     }
    4199                 :          0 :     auto result = AcceptToMemoryPool(active_chainstate, tx, GetTime(), /*bypass_limits=*/ false, test_accept);
    4200   [ #  #  #  #  :          0 :     active_chainstate.GetMempool()->check(active_chainstate.CoinsTip(), active_chainstate.m_chain.Height() + 1);
             #  #  #  # ]
    4201                 :          0 :     return result;
    4202         [ #  # ]:          0 : }
    4203                 :            : 
    4204                 :          0 : bool TestBlockValidity(BlockValidationState& state,
    4205                 :            :                        const CChainParams& chainparams,
    4206                 :            :                        Chainstate& chainstate,
    4207                 :            :                        const CBlock& block,
    4208                 :            :                        CBlockIndex* pindexPrev,
    4209                 :            :                        const std::function<NodeClock::time_point()>& adjusted_time_callback,
    4210                 :            :                        bool fCheckPOW,
    4211                 :            :                        bool fCheckMerkleRoot)
    4212                 :            : {
    4213                 :          0 :     AssertLockHeld(cs_main);
    4214   [ #  #  #  # ]:          0 :     assert(pindexPrev && pindexPrev == chainstate.m_chain.Tip());
    4215                 :          0 :     CCoinsViewCache viewNew(&chainstate.CoinsTip());
    4216         [ #  # ]:          0 :     uint256 block_hash(block.GetHash());
    4217         [ #  # ]:          0 :     CBlockIndex indexDummy(block);
    4218                 :          0 :     indexDummy.pprev = pindexPrev;
    4219                 :          0 :     indexDummy.nHeight = pindexPrev->nHeight + 1;
    4220                 :          0 :     indexDummy.phashBlock = &block_hash;
    4221                 :            : 
    4222                 :            :     // NOTE: CheckBlockHeader is called by CheckBlock
    4223   [ #  #  #  #  :          0 :     if (!ContextualCheckBlockHeader(block, state, chainstate.m_blockman, chainstate.m_chainman, pindexPrev, adjusted_time_callback()))
                   #  # ]
    4224   [ #  #  #  # ]:          0 :         return error("%s: Consensus::ContextualCheckBlockHeader: %s", __func__, state.ToString());
    4225   [ #  #  #  #  :          0 :     if (!CheckBlock(block, state, chainparams.GetConsensus(), fCheckPOW, fCheckMerkleRoot))
                   #  # ]
    4226   [ #  #  #  # ]:          0 :         return error("%s: Consensus::CheckBlock: %s", __func__, state.ToString());
    4227   [ #  #  #  # ]:          0 :     if (!ContextualCheckBlock(block, state, chainstate.m_chainman, pindexPrev))
    4228   [ #  #  #  # ]:          0 :         return error("%s: Consensus::ContextualCheckBlock: %s", __func__, state.ToString());
    4229   [ #  #  #  # ]:          0 :     if (!chainstate.ConnectBlock(block, state, &indexDummy, viewNew, true)) {
    4230                 :          0 :         return false;
    4231                 :            :     }
    4232   [ #  #  #  # ]:          0 :     assert(state.IsValid());
    4233                 :            : 
    4234                 :          0 :     return true;
    4235                 :          0 : }
    4236                 :            : 
    4237                 :            : /* This function is called from the RPC code for pruneblockchain */
    4238                 :          0 : void PruneBlockFilesManual(Chainstate& active_chainstate, int nManualPruneHeight)
    4239                 :            : {
    4240                 :          0 :     BlockValidationState state;
    4241   [ #  #  #  #  :          0 :     if (!active_chainstate.FlushStateToDisk(
                   #  # ]
    4242                 :          0 :             state, FlushStateMode::NONE, nManualPruneHeight)) {
    4243   [ #  #  #  #  :          0 :         LogPrintf("%s: failed to flush state (%s)\n", __func__, state.ToString());
             #  #  #  # ]
    4244                 :          0 :     }
    4245                 :          0 : }
    4246                 :            : 
    4247                 :          0 : bool Chainstate::LoadChainTip()
    4248                 :            : {
    4249                 :          0 :     AssertLockHeld(cs_main);
    4250                 :          0 :     const CCoinsViewCache& coins_cache = CoinsTip();
    4251         [ #  # ]:          0 :     assert(!coins_cache.GetBestBlock().IsNull()); // Never called when the coins view is empty
    4252                 :          0 :     const CBlockIndex* tip = m_chain.Tip();
    4253                 :            : 
    4254   [ #  #  #  # ]:          0 :     if (tip && tip->GetBlockHash() == coins_cache.GetBestBlock()) {
    4255                 :          0 :         return true;
    4256                 :            :     }
    4257                 :            : 
    4258                 :            :     // Load pointer to end of best chain
    4259                 :          0 :     CBlockIndex* pindex = m_blockman.LookupBlockIndex(coins_cache.GetBestBlock());
    4260         [ #  # ]:          0 :     if (!pindex) {
    4261                 :          0 :         return false;
    4262                 :            :     }
    4263                 :          0 :     m_chain.SetTip(*pindex);
    4264                 :          0 :     PruneBlockIndexCandidates();
    4265                 :            : 
    4266                 :          0 :     tip = m_chain.Tip();
    4267   [ #  #  #  #  :          0 :     LogPrintf("Loaded best chain: hashBestChain=%s height=%d date=%s progress=%f\n",
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
    4268                 :            :               tip->GetBlockHash().ToString(),
    4269                 :            :               m_chain.Height(),
    4270                 :            :               FormatISO8601DateTime(tip->GetBlockTime()),
    4271                 :            :               GuessVerificationProgress(m_chainman.GetParams().TxData(), tip));
    4272                 :          0 :     return true;
    4273                 :          0 : }
    4274                 :            : 
    4275                 :          0 : CVerifyDB::CVerifyDB(Notifications& notifications)
    4276                 :          0 :     : m_notifications{notifications}
    4277                 :            : {
    4278         [ #  # ]:          0 :     m_notifications.progress(_("Verifying blocks…"), 0, false);
    4279                 :          0 : }
    4280                 :            : 
    4281                 :          0 : CVerifyDB::~CVerifyDB()
    4282                 :            : {
    4283         [ #  # ]:          0 :     m_notifications.progress(bilingual_str{}, 100, false);
    4284                 :          0 : }
    4285                 :            : 
    4286                 :          0 : VerifyDBResult CVerifyDB::VerifyDB(
    4287                 :            :     Chainstate& chainstate,
    4288                 :            :     const Consensus::Params& consensus_params,
    4289                 :            :     CCoinsView& coinsview,
    4290                 :            :     int nCheckLevel, int nCheckDepth)
    4291                 :            : {
    4292                 :          0 :     AssertLockHeld(cs_main);
    4293                 :            : 
    4294   [ #  #  #  # ]:          0 :     if (chainstate.m_chain.Tip() == nullptr || chainstate.m_chain.Tip()->pprev == nullptr) {
    4295                 :          0 :         return VerifyDBResult::SUCCESS;
    4296                 :            :     }
    4297                 :            : 
    4298                 :            :     // Verify blocks in the best chain
    4299   [ #  #  #  # ]:          0 :     if (nCheckDepth <= 0 || nCheckDepth > chainstate.m_chain.Height()) {
    4300                 :          0 :         nCheckDepth = chainstate.m_chain.Height();
    4301                 :          0 :     }
    4302                 :          0 :     nCheckLevel = std::max(0, std::min(4, nCheckLevel));
    4303   [ #  #  #  #  :          0 :     LogPrintf("Verifying last %i blocks at level %i\n", nCheckDepth, nCheckLevel);
                   #  # ]
    4304                 :          0 :     CCoinsViewCache coins(&coinsview);
    4305                 :            :     CBlockIndex* pindex;
    4306                 :          0 :     CBlockIndex* pindexFailure = nullptr;
    4307                 :          0 :     int nGoodTransactions = 0;
    4308                 :          0 :     BlockValidationState state;
    4309                 :          0 :     int reportDone = 0;
    4310                 :          0 :     bool skipped_no_block_data{false};
    4311                 :          0 :     bool skipped_l3_checks{false};
    4312   [ #  #  #  #  :          0 :     LogPrintf("Verification progress: 0%%\n");
                   #  # ]
    4313                 :            : 
    4314                 :          0 :     const bool is_snapshot_cs{chainstate.m_from_snapshot_blockhash};
    4315                 :            : 
    4316   [ #  #  #  #  :          0 :     for (pindex = chainstate.m_chain.Tip(); pindex && pindex->pprev; pindex = pindex->pprev) {
                   #  # ]
    4317   [ #  #  #  #  :          0 :         const int percentageDone = std::max(1, std::min(99, (int)(((double)(chainstate.m_chain.Height() - pindex->nHeight)) / (double)nCheckDepth * (nCheckLevel >= 4 ? 50 : 100))));
                   #  # ]
    4318         [ #  # ]:          0 :         if (reportDone < percentageDone / 10) {
    4319                 :            :             // report every 10% step
    4320   [ #  #  #  #  :          0 :             LogPrintf("Verification progress: %d%%\n", percentageDone);
                   #  # ]
    4321                 :          0 :             reportDone = percentageDone / 10;
    4322                 :          0 :         }
    4323   [ #  #  #  # ]:          0 :         m_notifications.progress(_("Verifying blocks…"), percentageDone, false);
    4324   [ #  #  #  # ]:          0 :         if (pindex->nHeight <= chainstate.m_chain.Height() - nCheckDepth) {
    4325                 :          0 :             break;
    4326                 :            :         }
    4327   [ #  #  #  #  :          0 :         if ((chainstate.m_blockman.IsPruneMode() || is_snapshot_cs) && !(pindex->nStatus & BLOCK_HAVE_DATA)) {
                   #  # ]
    4328                 :            :             // If pruning or running under an assumeutxo snapshot, only go
    4329                 :            :             // back as far as we have data.
    4330   [ #  #  #  #  :          0 :             LogPrintf("VerifyDB(): block verification stopping at height %d (no data). This could be due to pruning or use of an assumeutxo snapshot.\n", pindex->nHeight);
                   #  # ]
    4331                 :          0 :             skipped_no_block_data = true;
    4332                 :          0 :             break;
    4333                 :            :         }
    4334         [ #  # ]:          0 :         CBlock block;
    4335                 :            :         // check level 0: read from disk
    4336   [ #  #  #  # ]:          0 :         if (!chainstate.m_blockman.ReadBlockFromDisk(block, *pindex)) {
    4337   [ #  #  #  #  :          0 :             LogPrintf("Verification error: ReadBlockFromDisk failed at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
          #  #  #  #  #  
                      # ]
    4338                 :          0 :             return VerifyDBResult::CORRUPTED_BLOCK_DB;
    4339                 :            :         }
    4340                 :            :         // check level 1: verify block validity
    4341   [ #  #  #  #  :          0 :         if (nCheckLevel >= 1 && !CheckBlock(block, state, consensus_params)) {
                   #  # ]
    4342   [ #  #  #  #  :          0 :             LogPrintf("Verification error: found bad block at %d, hash=%s (%s)\n",
          #  #  #  #  #  
                #  #  # ]
    4343                 :            :                       pindex->nHeight, pindex->GetBlockHash().ToString(), state.ToString());
    4344                 :          0 :             return VerifyDBResult::CORRUPTED_BLOCK_DB;
    4345                 :            :         }
    4346                 :            :         // check level 2: verify undo validity
    4347   [ #  #  #  # ]:          0 :         if (nCheckLevel >= 2 && pindex) {
    4348                 :          0 :             CBlockUndo undo;
    4349   [ #  #  #  #  :          0 :             if (!pindex->GetUndoPos().IsNull()) {
                   #  # ]
    4350   [ #  #  #  # ]:          0 :                 if (!chainstate.m_blockman.UndoReadFromDisk(undo, *pindex)) {
    4351   [ #  #  #  #  :          0 :                     LogPrintf("Verification error: found bad undo data at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
          #  #  #  #  #  
                      # ]
    4352                 :          0 :                     return VerifyDBResult::CORRUPTED_BLOCK_DB;
    4353                 :            :                 }
    4354                 :          0 :             }
    4355         [ #  # ]:          0 :         }
    4356                 :            :         // check level 3: check for inconsistencies during memory-only disconnect of tip blocks
    4357   [ #  #  #  #  :          0 :         size_t curr_coins_usage = coins.DynamicMemoryUsage() + chainstate.CoinsTip().DynamicMemoryUsage();
                   #  # ]
    4358                 :            : 
    4359         [ #  # ]:          0 :         if (nCheckLevel >= 3) {
    4360         [ #  # ]:          0 :             if (curr_coins_usage <= chainstate.m_coinstip_cache_size_bytes) {
    4361   [ #  #  #  #  :          0 :                 assert(coins.GetBestBlock() == pindex->GetBlockHash());
             #  #  #  # ]
    4362         [ #  # ]:          0 :                 DisconnectResult res = chainstate.DisconnectBlock(block, pindex, coins);
    4363         [ #  # ]:          0 :                 if (res == DISCONNECT_FAILED) {
    4364   [ #  #  #  #  :          0 :                     LogPrintf("Verification error: irrecoverable inconsistency in block data at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
          #  #  #  #  #  
                      # ]
    4365                 :          0 :                     return VerifyDBResult::CORRUPTED_BLOCK_DB;
    4366                 :            :                 }
    4367         [ #  # ]:          0 :                 if (res == DISCONNECT_UNCLEAN) {
    4368                 :          0 :                     nGoodTransactions = 0;
    4369                 :          0 :                     pindexFailure = pindex;
    4370                 :          0 :                 } else {
    4371                 :          0 :                     nGoodTransactions += block.vtx.size();
    4372                 :            :                 }
    4373                 :          0 :             } else {
    4374                 :          0 :                 skipped_l3_checks = true;
    4375                 :            :             }
    4376                 :          0 :         }
    4377   [ #  #  #  # ]:          0 :         if (chainstate.m_chainman.m_interrupt) return VerifyDBResult::INTERRUPTED;
    4378         [ #  # ]:          0 :     }
    4379         [ #  # ]:          0 :     if (pindexFailure) {
    4380   [ #  #  #  #  :          0 :         LogPrintf("Verification error: coin database inconsistencies found (last %i blocks, %i good transactions before that)\n", chainstate.m_chain.Height() - pindexFailure->nHeight + 1, nGoodTransactions);
             #  #  #  # ]
    4381                 :          0 :         return VerifyDBResult::CORRUPTED_BLOCK_DB;
    4382                 :            :     }
    4383         [ #  # ]:          0 :     if (skipped_l3_checks) {
    4384   [ #  #  #  #  :          0 :         LogPrintf("Skipped verification of level >=3 (insufficient database cache size). Consider increasing -dbcache.\n");
                   #  # ]
    4385                 :          0 :     }
    4386                 :            : 
    4387                 :            :     // store block count as we move pindex at check level >= 4
    4388         [ #  # ]:          0 :     int block_count = chainstate.m_chain.Height() - pindex->nHeight;
    4389                 :            : 
    4390                 :            :     // check level 4: try reconnecting blocks
    4391   [ #  #  #  # ]:          0 :     if (nCheckLevel >= 4 && !skipped_l3_checks) {
    4392   [ #  #  #  # ]:          0 :         while (pindex != chainstate.m_chain.Tip()) {
    4393   [ #  #  #  #  :          0 :             const int percentageDone = std::max(1, std::min(99, 100 - (int)(((double)(chainstate.m_chain.Height() - pindex->nHeight)) / (double)nCheckDepth * 50)));
                   #  # ]
    4394         [ #  # ]:          0 :             if (reportDone < percentageDone / 10) {
    4395                 :            :                 // report every 10% step
    4396   [ #  #  #  #  :          0 :                 LogPrintf("Verification progress: %d%%\n", percentageDone);
                   #  # ]
    4397                 :          0 :                 reportDone = percentageDone / 10;
    4398                 :          0 :             }
    4399   [ #  #  #  # ]:          0 :             m_notifications.progress(_("Verifying blocks…"), percentageDone, false);
    4400         [ #  # ]:          0 :             pindex = chainstate.m_chain.Next(pindex);
    4401         [ #  # ]:          0 :             CBlock block;
    4402   [ #  #  #  # ]:          0 :             if (!chainstate.m_blockman.ReadBlockFromDisk(block, *pindex)) {
    4403   [ #  #  #  #  :          0 :                 LogPrintf("Verification error: ReadBlockFromDisk failed at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
          #  #  #  #  #  
                      # ]
    4404                 :          0 :                 return VerifyDBResult::CORRUPTED_BLOCK_DB;
    4405                 :            :             }
    4406   [ #  #  #  # ]:          0 :             if (!chainstate.ConnectBlock(block, state, pindex, coins)) {
    4407   [ #  #  #  #  :          0 :                 LogPrintf("Verification error: found unconnectable block at %d, hash=%s (%s)\n", pindex->nHeight, pindex->GetBlockHash().ToString(), state.ToString());
          #  #  #  #  #  
                #  #  # ]
    4408                 :          0 :                 return VerifyDBResult::CORRUPTED_BLOCK_DB;
    4409                 :            :             }
    4410   [ #  #  #  # ]:          0 :             if (chainstate.m_chainman.m_interrupt) return VerifyDBResult::INTERRUPTED;
    4411         [ #  # ]:          0 :         }
    4412                 :          0 :     }
    4413                 :            : 
    4414   [ #  #  #  #  :          0 :     LogPrintf("Verification: No coin database inconsistencies in last %i blocks (%i transactions)\n", block_count, nGoodTransactions);
                   #  # ]
    4415                 :            : 
    4416         [ #  # ]:          0 :     if (skipped_l3_checks) {
    4417                 :          0 :         return VerifyDBResult::SKIPPED_L3_CHECKS;
    4418                 :            :     }
    4419         [ #  # ]:          0 :     if (skipped_no_block_data) {
    4420                 :          0 :         return VerifyDBResult::SKIPPED_MISSING_BLOCKS;
    4421                 :            :     }
    4422                 :          0 :     return VerifyDBResult::SUCCESS;
    4423                 :          0 : }
    4424                 :            : 
    4425                 :            : /** Apply the effects of a block on the utxo cache, ignoring that it may already have been applied. */
    4426                 :          0 : bool Chainstate::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& inputs)
    4427                 :            : {
    4428                 :          0 :     AssertLockHeld(cs_main);
    4429                 :            :     // TODO: merge with ConnectBlock
    4430                 :          0 :     CBlock block;
    4431   [ #  #  #  # ]:          0 :     if (!m_blockman.ReadBlockFromDisk(block, *pindex)) {
    4432   [ #  #  #  #  :          0 :         return error("ReplayBlock(): ReadBlockFromDisk failed at %d, hash=%s", pindex->nHeight, pindex->GetBlockHash().ToString());
                   #  # ]
    4433                 :            :     }
    4434                 :            : 
    4435         [ #  # ]:          0 :     for (const CTransactionRef& tx : block.vtx) {
    4436   [ #  #  #  # ]:          0 :         if (!tx->IsCoinBase()) {
    4437         [ #  # ]:          0 :             for (const CTxIn &txin : tx->vin) {
    4438         [ #  # ]:          0 :                 inputs.SpendCoin(txin.prevout);
    4439                 :            :             }
    4440                 :          0 :         }
    4441                 :            :         // Pass check = true as every addition may be an overwrite.
    4442         [ #  # ]:          0 :         AddCoins(inputs, *tx, pindex->nHeight, true);
    4443                 :            :     }
    4444                 :          0 :     return true;
    4445                 :          0 : }
    4446                 :            : 
    4447                 :          1 : bool Chainstate::ReplayBlocks()
    4448                 :            : {
    4449                 :          1 :     LOCK(cs_main);
    4450                 :            : 
    4451         [ +  - ]:          1 :     CCoinsView& db = this->CoinsDB();
    4452         [ +  - ]:          1 :     CCoinsViewCache cache(&db);
    4453                 :            : 
    4454         [ +  - ]:          1 :     std::vector<uint256> hashHeads = db.GetHeadBlocks();
    4455         [ +  - ]:          1 :     if (hashHeads.empty()) return true; // We're already in a consistent state.
    4456   [ #  #  #  # ]:          0 :     if (hashHeads.size() != 2) return error("ReplayBlocks(): unknown inconsistent state");
    4457                 :            : 
    4458   [ #  #  #  #  :          0 :     m_chainman.GetNotifications().progress(_("Replaying blocks…"), 0, false);
                   #  # ]
    4459   [ #  #  #  #  :          0 :     LogPrintf("Replaying blocks\n");
                   #  # ]
    4460                 :            : 
    4461                 :          0 :     const CBlockIndex* pindexOld = nullptr;  // Old tip during the interrupted flush.
    4462                 :            :     const CBlockIndex* pindexNew;            // New tip during the interrupted flush.
    4463                 :          0 :     const CBlockIndex* pindexFork = nullptr; // Latest block common to both the old and the new tip.
    4464                 :            : 
    4465   [ #  #  #  # ]:          0 :     if (m_blockman.m_block_index.count(hashHeads[0]) == 0) {
    4466         [ #  # ]:          0 :         return error("ReplayBlocks(): reorganization to unknown block requested");
    4467                 :            :     }
    4468         [ #  # ]:          0 :     pindexNew = &(m_blockman.m_block_index[hashHeads[0]]);
    4469                 :            : 
    4470   [ #  #  #  # ]:          0 :     if (!hashHeads[1].IsNull()) { // The old tip is allowed to be 0, indicating it's the first flush.
    4471   [ #  #  #  # ]:          0 :         if (m_blockman.m_block_index.count(hashHeads[1]) == 0) {
    4472         [ #  # ]:          0 :             return error("ReplayBlocks(): reorganization from unknown block requested");
    4473                 :            :         }
    4474         [ #  # ]:          0 :         pindexOld = &(m_blockman.m_block_index[hashHeads[1]]);
    4475         [ #  # ]:          0 :         pindexFork = LastCommonAncestor(pindexOld, pindexNew);
    4476         [ #  # ]:          0 :         assert(pindexFork != nullptr);
    4477                 :          0 :     }
    4478                 :            : 
    4479                 :            :     // Rollback along the old branch.
    4480         [ #  # ]:          0 :     while (pindexOld != pindexFork) {
    4481         [ #  # ]:          0 :         if (pindexOld->nHeight > 0) { // Never disconnect the genesis block.
    4482         [ #  # ]:          0 :             CBlock block;
    4483   [ #  #  #  # ]:          0 :             if (!m_blockman.ReadBlockFromDisk(block, *pindexOld)) {
    4484   [ #  #  #  #  :          0 :                 return error("RollbackBlock(): ReadBlockFromDisk() failed at %d, hash=%s", pindexOld->nHeight, pindexOld->GetBlockHash().ToString());
                   #  # ]
    4485                 :            :             }
    4486   [ #  #  #  #  :          0 :             LogPrintf("Rolling back %s (%i)\n", pindexOld->GetBlockHash().ToString(), pindexOld->nHeight);
          #  #  #  #  #  
                      # ]
    4487         [ #  # ]:          0 :             DisconnectResult res = DisconnectBlock(block, pindexOld, cache);
    4488         [ #  # ]:          0 :             if (res == DISCONNECT_FAILED) {
    4489   [ #  #  #  #  :          0 :                 return error("RollbackBlock(): DisconnectBlock failed at %d, hash=%s", pindexOld->nHeight, pindexOld->GetBlockHash().ToString());
                   #  # ]
    4490                 :            :             }
    4491                 :            :             // If DISCONNECT_UNCLEAN is returned, it means a non-existing UTXO was deleted, or an existing UTXO was
    4492                 :            :             // overwritten. It corresponds to cases where the block-to-be-disconnect never had all its operations
    4493                 :            :             // applied to the UTXO set. However, as both writing a UTXO and deleting a UTXO are idempotent operations,
    4494                 :            :             // the result is still a version of the UTXO set with the effects of that block undone.
    4495         [ #  # ]:          0 :         }
    4496                 :          0 :         pindexOld = pindexOld->pprev;
    4497                 :            :     }
    4498                 :            : 
    4499                 :            :     // Roll forward from the forking point to the new tip.
    4500         [ #  # ]:          0 :     int nForkHeight = pindexFork ? pindexFork->nHeight : 0;
    4501         [ #  # ]:          0 :     for (int nHeight = nForkHeight + 1; nHeight <= pindexNew->nHeight; ++nHeight) {
    4502   [ #  #  #  # ]:          0 :         const CBlockIndex& pindex{*Assert(pindexNew->GetAncestor(nHeight))};
    4503                 :            : 
    4504   [ #  #  #  #  :          0 :         LogPrintf("Rolling forward %s (%i)\n", pindex.GetBlockHash().ToString(), nHeight);
          #  #  #  #  #  
                      # ]
    4505   [ #  #  #  #  :          0 :         m_chainman.GetNotifications().progress(_("Replaying blocks…"), (int)((nHeight - nForkHeight) * 100.0 / (pindexNew->nHeight - nForkHeight)), false);
                   #  # ]
    4506   [ #  #  #  # ]:          0 :         if (!RollforwardBlock(&pindex, cache)) return false;
    4507                 :          0 :     }
    4508                 :            : 
    4509   [ #  #  #  # ]:          0 :     cache.SetBestBlock(pindexNew->GetBlockHash());
    4510         [ #  # ]:          0 :     cache.Flush();
    4511   [ #  #  #  # ]:          0 :     m_chainman.GetNotifications().progress(bilingual_str{}, 100, false);
    4512                 :          0 :     return true;
    4513                 :          1 : }
    4514                 :            : 
    4515                 :          1 : bool Chainstate::NeedsRedownload() const
    4516                 :            : {
    4517                 :          1 :     AssertLockHeld(cs_main);
    4518                 :            : 
    4519                 :            :     // At and above m_params.SegwitHeight, segwit consensus rules must be validated
    4520                 :          1 :     CBlockIndex* block{m_chain.Tip()};
    4521                 :            : 
    4522   [ +  -  -  + ]:          1 :     while (block != nullptr && DeploymentActiveAt(*block, m_chainman, Consensus::DEPLOYMENT_SEGWIT)) {
    4523         [ #  # ]:          0 :         if (!(block->nStatus & BLOCK_OPT_WITNESS)) {
    4524                 :            :             // block is insufficiently validated for a segwit client
    4525                 :          0 :             return true;
    4526                 :            :         }
    4527                 :          0 :         block = block->pprev;
    4528                 :            :     }
    4529                 :            : 
    4530                 :          1 :     return false;
    4531                 :          1 : }
    4532                 :            : 
    4533                 :          0 : void Chainstate::ClearBlockIndexCandidates()
    4534                 :            : {
    4535                 :          0 :     AssertLockHeld(::cs_main);
    4536                 :          0 :     setBlockIndexCandidates.clear();
    4537                 :          0 : }
    4538                 :            : 
    4539                 :          1 : bool ChainstateManager::LoadBlockIndex()
    4540                 :            : {
    4541                 :          1 :     AssertLockHeld(cs_main);
    4542                 :            :     // Load block index from databases
    4543                 :          1 :     bool needs_init = fReindex;
    4544         [ -  + ]:          1 :     if (!fReindex) {
    4545                 :          1 :         bool ret{m_blockman.LoadBlockIndexDB(SnapshotBlockhash())};
    4546         [ +  - ]:          1 :         if (!ret) return false;
    4547                 :            : 
    4548                 :          1 :         m_blockman.ScanAndUnlinkAlreadyPrunedFiles();
    4549                 :            : 
    4550                 :          1 :         std::vector<CBlockIndex*> vSortedByHeight{m_blockman.GetAllBlockIndices()};
    4551         [ +  - ]:          1 :         std::sort(vSortedByHeight.begin(), vSortedByHeight.end(),
    4552                 :            :                   CBlockIndexHeightOnlyComparator());
    4553                 :            : 
    4554         [ +  - ]:          1 :         for (CBlockIndex* pindex : vSortedByHeight) {
    4555   [ #  #  #  # ]:          0 :             if (m_interrupt) return false;
    4556                 :            :             // If we have an assumeutxo-based chainstate, then the snapshot
    4557                 :            :             // block will be a candidate for the tip, but it may not be
    4558                 :            :             // VALID_TRANSACTIONS (eg if we haven't yet downloaded the block),
    4559                 :            :             // so we special-case the snapshot block as a potential candidate
    4560                 :            :             // here.
    4561   [ #  #  #  # ]:          0 :             if (pindex == GetSnapshotBaseBlock() ||
    4562   [ #  #  #  # ]:          0 :                     (pindex->IsValid(BLOCK_VALID_TRANSACTIONS) &&
    4563   [ #  #  #  # ]:          0 :                      (pindex->HaveTxsDownloaded() || pindex->pprev == nullptr))) {
    4564                 :            : 
    4565   [ #  #  #  # ]:          0 :                 for (Chainstate* chainstate : GetAll()) {
    4566         [ #  # ]:          0 :                     chainstate->TryAddBlockIndexCandidate(pindex);
    4567                 :            :                 }
    4568                 :          0 :             }
    4569   [ #  #  #  #  :          0 :             if (pindex->nStatus & BLOCK_FAILED_MASK && (!m_best_invalid || pindex->nChainWork > m_best_invalid->nChainWork)) {
             #  #  #  # ]
    4570                 :          0 :                 m_best_invalid = pindex;
    4571                 :          0 :             }
    4572   [ #  #  #  #  :          0 :             if (pindex->IsValid(BLOCK_VALID_TREE) && (m_best_header == nullptr || CBlockIndexWorkComparator()(m_best_header, pindex)))
          #  #  #  #  #  
                      # ]
    4573                 :          0 :                 m_best_header = pindex;
    4574                 :            :         }
    4575                 :            : 
    4576                 :          1 :         needs_init = m_blockman.m_block_index.empty();
    4577      [ -  -  + ]:          1 :     }
    4578                 :            : 
    4579         [ -  + ]:          1 :     if (needs_init) {
    4580                 :            :         // Everything here is for *new* reindex/DBs. Thus, though
    4581                 :            :         // LoadBlockIndexDB may have set fReindex if we shut down
    4582                 :            :         // mid-reindex previously, we don't check fReindex and
    4583                 :            :         // instead only check it prior to LoadBlockIndexDB to set
    4584                 :            :         // needs_init.
    4585                 :            : 
    4586   [ +  -  +  -  :          1 :         LogPrintf("Initializing databases...\n");
                   +  - ]
    4587                 :          1 :     }
    4588                 :          1 :     return true;
    4589                 :          1 : }
    4590                 :            : 
    4591                 :          1 : bool Chainstate::LoadGenesisBlock()
    4592                 :            : {
    4593                 :          1 :     LOCK(cs_main);
    4594                 :            : 
    4595         [ +  - ]:          1 :     const CChainParams& params{m_chainman.GetParams()};
    4596                 :            : 
    4597                 :            :     // Check whether we're already initialized by checking for genesis in
    4598                 :            :     // m_blockman.m_block_index. Note that we can't use m_chain here, since it is
    4599                 :            :     // set based on the coins db, not the block index db, which is the only
    4600                 :            :     // thing loaded at this point.
    4601   [ +  -  +  -  :          1 :     if (m_blockman.m_block_index.count(params.GenesisBlock().GetHash()))
             +  -  -  + ]
    4602                 :          0 :         return true;
    4603                 :            : 
    4604                 :            :     try {
    4605         [ +  - ]:          1 :         const CBlock& block = params.GenesisBlock();
    4606         [ +  - ]:          1 :         FlatFilePos blockPos{m_blockman.SaveBlockToDisk(block, 0, nullptr)};
    4607   [ +  -  -  + ]:          1 :         if (blockPos.IsNull()) {
    4608         [ #  # ]:          0 :             return error("%s: writing genesis block to disk failed", __func__);
    4609                 :            :         }
    4610         [ +  - ]:          1 :         CBlockIndex* pindex = m_blockman.AddToBlockIndex(block, m_chainman.m_best_header);
    4611         [ +  - ]:          1 :         m_chainman.ReceivedBlockTransactions(block, pindex, blockPos);
    4612         [ #  # ]:          1 :     } catch (const std::runtime_error& e) {
    4613         [ #  # ]:          0 :         return error("%s: failed to write genesis block: %s", __func__, e.what());
    4614   [ #  #  #  # ]:          0 :     }
    4615                 :            : 
    4616                 :          1 :     return true;
    4617                 :          1 : }
    4618                 :            : 
    4619                 :          0 : void ChainstateManager::LoadExternalBlockFile(
    4620                 :            :     CAutoFile& file_in,
    4621                 :            :     FlatFilePos* dbp,
    4622                 :            :     std::multimap<uint256, FlatFilePos>* blocks_with_unknown_parent)
    4623                 :            : {
    4624                 :            :     // Either both should be specified (-reindex), or neither (-loadblock).
    4625         [ #  # ]:          0 :     assert(!dbp == !blocks_with_unknown_parent);
    4626                 :            : 
    4627                 :          0 :     const auto start{SteadyClock::now()};
    4628                 :          0 :     const CChainParams& params{GetParams()};
    4629                 :            : 
    4630                 :          0 :     int nLoaded = 0;
    4631                 :            :     try {
    4632         [ #  # ]:          0 :         BufferedFile blkdat{file_in, 2 * MAX_BLOCK_SERIALIZED_SIZE, MAX_BLOCK_SERIALIZED_SIZE + 8};
    4633                 :            :         // nRewind indicates where to resume scanning in case something goes wrong,
    4634                 :            :         // such as a block fails to deserialize.
    4635         [ #  # ]:          0 :         uint64_t nRewind = blkdat.GetPos();
    4636   [ #  #  #  # ]:          0 :         while (!blkdat.eof()) {
    4637   [ #  #  #  # ]:          0 :             if (m_interrupt) return;
    4638                 :            : 
    4639         [ #  # ]:          0 :             blkdat.SetPos(nRewind);
    4640                 :          0 :             nRewind++; // start one byte further next time, in case of failure
    4641         [ #  # ]:          0 :             blkdat.SetLimit(); // remove former limit
    4642                 :          0 :             unsigned int nSize = 0;
    4643                 :            :             try {
    4644                 :            :                 // locate a header
    4645                 :            :                 MessageStartChars buf;
    4646   [ #  #  #  # ]:          0 :                 blkdat.FindByte(std::byte(params.MessageStart()[0]));
    4647         [ #  # ]:          0 :                 nRewind = blkdat.GetPos() + 1;
    4648         [ #  # ]:          0 :                 blkdat >> buf;
    4649   [ #  #  #  #  :          0 :                 if (buf != params.MessageStart()) {
                   #  # ]
    4650                 :          0 :                     continue;
    4651                 :            :                 }
    4652                 :            :                 // read size
    4653         [ #  # ]:          0 :                 blkdat >> nSize;
    4654   [ #  #  #  # ]:          0 :                 if (nSize < 80 || nSize > MAX_BLOCK_SERIALIZED_SIZE)
    4655                 :          0 :                     continue;
    4656         [ #  # ]:          0 :             } catch (const std::exception&) {
    4657                 :            :                 // no valid block header found; don't complain
    4658                 :            :                 // (this happens at the end of every blk.dat file)
    4659                 :            :                 break;
    4660         [ #  # ]:          0 :             }
    4661                 :            :             try {
    4662                 :            :                 // read block header
    4663         [ #  # ]:          0 :                 const uint64_t nBlockPos{blkdat.GetPos()};
    4664         [ #  # ]:          0 :                 if (dbp)
    4665                 :          0 :                     dbp->nPos = nBlockPos;
    4666         [ #  # ]:          0 :                 blkdat.SetLimit(nBlockPos + nSize);
    4667         [ #  # ]:          0 :                 CBlockHeader header;
    4668         [ #  # ]:          0 :                 blkdat >> header;
    4669         [ #  # ]:          0 :                 const uint256 hash{header.GetHash()};
    4670                 :            :                 // Skip the rest of this block (this may read from disk into memory); position to the marker before the
    4671                 :            :                 // next block, but it's still possible to rewind to the start of the current block (without a disk read).
    4672                 :          0 :                 nRewind = nBlockPos + nSize;
    4673         [ #  # ]:          0 :                 blkdat.SkipTo(nRewind);
    4674                 :            : 
    4675                 :          0 :                 std::shared_ptr<CBlock> pblock{}; // needs to remain available after the cs_main lock is released to avoid duplicate reads from disk
    4676                 :            : 
    4677                 :            :                 {
    4678   [ #  #  #  # ]:          0 :                     LOCK(cs_main);
    4679                 :            :                     // detect out of order blocks, and store them for later
    4680   [ #  #  #  #  :          0 :                     if (hash != params.GetConsensus().hashGenesisBlock && !m_blockman.LookupBlockIndex(header.hashPrevBlock)) {
          #  #  #  #  #  
                      # ]
    4681   [ #  #  #  #  :          0 :                         LogPrint(BCLog::REINDEX, "%s: Out of order block %s, parent %s not known\n", __func__, hash.ToString(),
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    4682                 :            :                                  header.hashPrevBlock.ToString());
    4683   [ #  #  #  # ]:          0 :                         if (dbp && blocks_with_unknown_parent) {
    4684         [ #  # ]:          0 :                             blocks_with_unknown_parent->emplace(header.hashPrevBlock, *dbp);
    4685                 :          0 :                         }
    4686                 :          0 :                         continue;
    4687                 :            :                     }
    4688                 :            : 
    4689                 :            :                     // process in case the block isn't known yet
    4690         [ #  # ]:          0 :                     const CBlockIndex* pindex = m_blockman.LookupBlockIndex(hash);
    4691   [ #  #  #  # ]:          0 :                     if (!pindex || (pindex->nStatus & BLOCK_HAVE_DATA) == 0) {
    4692                 :            :                         // This block can be processed immediately; rewind to its start, read and deserialize it.
    4693         [ #  # ]:          0 :                         blkdat.SetPos(nBlockPos);
    4694         [ #  # ]:          0 :                         pblock = std::make_shared<CBlock>();
    4695         [ #  # ]:          0 :                         blkdat >> *pblock;
    4696         [ #  # ]:          0 :                         nRewind = blkdat.GetPos();
    4697                 :            : 
    4698                 :          0 :                         BlockValidationState state;
    4699   [ #  #  #  # ]:          0 :                         if (AcceptBlock(pblock, state, nullptr, true, dbp, nullptr, true)) {
    4700                 :          0 :                             nLoaded++;
    4701                 :          0 :                         }
    4702   [ #  #  #  # ]:          0 :                         if (state.IsError()) {
    4703                 :          0 :                             break;
    4704                 :            :                         }
    4705   [ #  #  #  #  :          0 :                     } else if (hash != params.GetConsensus().hashGenesisBlock && pindex->nHeight % 1000 == 0) {
          #  #  #  #  #  
                      # ]
    4706   [ #  #  #  #  :          0 :                         LogPrint(BCLog::REINDEX, "Block Import: already had block %s at height %d\n", hash.ToString(), pindex->nHeight);
          #  #  #  #  #  
                #  #  # ]
    4707                 :          0 :                     }
    4708         [ #  # ]:          0 :                 }
    4709                 :            : 
    4710                 :            :                 // Activate the genesis block so normal node progress can continue
    4711   [ #  #  #  #  :          0 :                 if (hash == params.GetConsensus().hashGenesisBlock) {
                   #  # ]
    4712                 :          0 :                     bool genesis_activation_failure = false;
    4713   [ #  #  #  # ]:          0 :                     for (auto c : GetAll()) {
    4714                 :          0 :                         BlockValidationState state;
    4715   [ #  #  #  # ]:          0 :                         if (!c->ActivateBestChain(state, nullptr)) {
    4716                 :          0 :                             genesis_activation_failure = true;
    4717                 :          0 :                             break;
    4718                 :            :                         }
    4719         [ #  # ]:          0 :                     }
    4720         [ #  # ]:          0 :                     if (genesis_activation_failure) {
    4721                 :          0 :                         break;
    4722                 :            :                     }
    4723                 :          0 :                 }
    4724                 :            : 
    4725   [ #  #  #  #  :          0 :                 if (m_blockman.IsPruneMode() && !fReindex && pblock) {
          #  #  #  #  #  
                      # ]
    4726                 :            :                     // must update the tip for pruning to work while importing with -loadblock.
    4727                 :            :                     // this is a tradeoff to conserve disk space at the expense of time
    4728                 :            :                     // spent updating the tip to be able to prune.
    4729                 :            :                     // otherwise, ActivateBestChain won't be called by the import process
    4730                 :            :                     // until after all of the block files are loaded. ActivateBestChain can be
    4731                 :            :                     // called by concurrent network message processing. but, that is not
    4732                 :            :                     // reliable for the purpose of pruning while importing.
    4733                 :          0 :                     bool activation_failure = false;
    4734   [ #  #  #  # ]:          0 :                     for (auto c : GetAll()) {
    4735                 :          0 :                         BlockValidationState state;
    4736   [ #  #  #  # ]:          0 :                         if (!c->ActivateBestChain(state, pblock)) {
    4737   [ #  #  #  #  :          0 :                             LogPrint(BCLog::REINDEX, "failed to activate chain (%s)\n", state.ToString());
          #  #  #  #  #  
                #  #  # ]
    4738                 :          0 :                             activation_failure = true;
    4739                 :          0 :                             break;
    4740                 :            :                         }
    4741         [ #  # ]:          0 :                     }
    4742         [ #  # ]:          0 :                     if (activation_failure) {
    4743                 :          0 :                         break;
    4744                 :            :                     }
    4745                 :          0 :                 }
    4746                 :            : 
    4747         [ #  # ]:          0 :                 NotifyHeaderTip(*this);
    4748                 :            : 
    4749         [ #  # ]:          0 :                 if (!blocks_with_unknown_parent) continue;
    4750                 :            : 
    4751                 :            :                 // Recursively process earlier encountered successors of this block
    4752         [ #  # ]:          0 :                 std::deque<uint256> queue;
    4753         [ #  # ]:          0 :                 queue.push_back(hash);
    4754         [ #  # ]:          0 :                 while (!queue.empty()) {
    4755                 :          0 :                     uint256 head = queue.front();
    4756                 :          0 :                     queue.pop_front();
    4757         [ #  # ]:          0 :                     auto range = blocks_with_unknown_parent->equal_range(head);
    4758         [ #  # ]:          0 :                     while (range.first != range.second) {
    4759                 :          0 :                         std::multimap<uint256, FlatFilePos>::iterator it = range.first;
    4760         [ #  # ]:          0 :                         std::shared_ptr<CBlock> pblockrecursive = std::make_shared<CBlock>();
    4761   [ #  #  #  # ]:          0 :                         if (m_blockman.ReadBlockFromDisk(*pblockrecursive, it->second)) {
    4762   [ #  #  #  #  :          0 :                             LogPrint(BCLog::REINDEX, "%s: Processing out of order child %s of %s\n", __func__, pblockrecursive->GetHash().ToString(),
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    4763                 :            :                                     head.ToString());
    4764   [ #  #  #  # ]:          0 :                             LOCK(cs_main);
    4765                 :          0 :                             BlockValidationState dummy;
    4766   [ #  #  #  # ]:          0 :                             if (AcceptBlock(pblockrecursive, dummy, nullptr, true, &it->second, nullptr, true)) {
    4767                 :          0 :                                 nLoaded++;
    4768   [ #  #  #  # ]:          0 :                                 queue.push_back(pblockrecursive->GetHash());
    4769                 :          0 :                             }
    4770                 :          0 :                         }
    4771                 :          0 :                         range.first++;
    4772         [ #  # ]:          0 :                         blocks_with_unknown_parent->erase(it);
    4773         [ #  # ]:          0 :                         NotifyHeaderTip(*this);
    4774                 :          0 :                     }
    4775                 :            :                 }
    4776   [ #  #  #  #  :          0 :             } catch (const std::exception& e) {
                      # ]
    4777                 :            :                 // historical bugs added extra data to the block files that does not deserialize cleanly.
    4778                 :            :                 // commonly this data is between readable blocks, but it does not really matter. such data is not fatal to the import process.
    4779                 :            :                 // the code that reads the block files deals with invalid data by simply ignoring it.
    4780                 :            :                 // it continues to search for the next {4 byte magic message start bytes + 4 byte length + block} that does deserialize cleanly
    4781                 :            :                 // and passes all of the other block validation checks dealing with POW and the merkle root, etc...
    4782                 :            :                 // we merely note with this informational log message when unexpected data is encountered.
    4783                 :            :                 // we could also be experiencing a storage system read error, or a read of a previous bad write. these are possible, but
    4784                 :            :                 // less likely scenarios. we don't have enough information to tell a difference here.
    4785                 :            :                 // the reindex process is not the place to attempt to clean and/or compact the block files. if so desired, a studious node operator
    4786                 :            :                 // may use knowledge of the fact that the block files are not entirely pristine in order to prepare a set of pristine, and
    4787                 :            :                 // perhaps ordered, block files for later reindexing.
    4788   [ #  #  #  #  :          0 :                 LogPrint(BCLog::REINDEX, "%s: unexpected data at file offset 0x%x - %s. continuing\n", __func__, (nRewind - 1), e.what());
          #  #  #  #  #  
                      # ]
    4789   [ #  #  #  # ]:          0 :             }
    4790                 :            :         }
    4791   [ #  #  #  # ]:          0 :     } catch (const std::runtime_error& e) {
    4792   [ #  #  #  #  :          0 :         GetNotifications().fatalError(std::string("System error: ") + e.what());
             #  #  #  # ]
    4793         [ #  # ]:          0 :     }
    4794   [ #  #  #  #  :          0 :     LogPrintf("Loaded %i blocks from external file in %dms\n", nLoaded, Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
          #  #  #  #  #  
                      # ]
    4795                 :          0 : }
    4796                 :            : 
    4797                 :          1 : void ChainstateManager::CheckBlockIndex()
    4798                 :            : {
    4799         [ +  - ]:          1 :     if (!ShouldCheckBlockIndex()) {
    4800                 :          0 :         return;
    4801                 :            :     }
    4802                 :            : 
    4803                 :          1 :     LOCK(cs_main);
    4804                 :            : 
    4805                 :            :     // During a reindex, we read the genesis block and call CheckBlockIndex before ActivateBestChain,
    4806                 :            :     // so we have the genesis block in m_blockman.m_block_index but no active chain. (A few of the
    4807                 :            :     // tests when iterating the block tree require that m_chain has been initialized.)
    4808   [ +  -  +  -  :          1 :     if (ActiveChain().Height() < 0) {
                   +  - ]
    4809         [ #  # ]:          0 :         assert(m_blockman.m_block_index.size() <= 1);
    4810                 :          0 :         return;
    4811                 :            :     }
    4812                 :            : 
    4813                 :            :     // Build forward-pointing map of the entire block tree.
    4814                 :          1 :     std::multimap<CBlockIndex*,CBlockIndex*> forward;
    4815         [ +  + ]:          2 :     for (auto& [_, block_index] : m_blockman.m_block_index) {
    4816   [ +  -  +  - ]:          2 :         forward.emplace(block_index.pprev, &block_index);
    4817                 :            :     }
    4818                 :            : 
    4819         [ +  - ]:          1 :     assert(forward.size() == m_blockman.m_block_index.size());
    4820                 :            : 
    4821         [ +  - ]:          1 :     std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> rangeGenesis = forward.equal_range(nullptr);
    4822                 :          1 :     CBlockIndex *pindex = rangeGenesis.first->second;
    4823                 :          1 :     rangeGenesis.first++;
    4824         [ +  - ]:          1 :     assert(rangeGenesis.first == rangeGenesis.second); // There is only one index entry with parent nullptr.
    4825                 :            : 
    4826                 :            :     // Iterate over the entire block tree, using depth-first search.
    4827                 :            :     // Along the way, remember whether there are blocks on the path from genesis
    4828                 :            :     // block being explored which are the first to have certain properties.
    4829                 :          1 :     size_t nNodes = 0;
    4830                 :          1 :     int nHeight = 0;
    4831                 :          1 :     CBlockIndex* pindexFirstInvalid = nullptr; // Oldest ancestor of pindex which is invalid.
    4832                 :          1 :     CBlockIndex* pindexFirstMissing = nullptr; // Oldest ancestor of pindex which does not have BLOCK_HAVE_DATA.
    4833                 :          1 :     CBlockIndex* pindexFirstNeverProcessed = nullptr; // Oldest ancestor of pindex for which nTx == 0.
    4834                 :          1 :     CBlockIndex* pindexFirstNotTreeValid = nullptr; // Oldest ancestor of pindex which does not have BLOCK_VALID_TREE (regardless of being valid or not).
    4835                 :          1 :     CBlockIndex* pindexFirstNotTransactionsValid = nullptr; // Oldest ancestor of pindex which does not have BLOCK_VALID_TRANSACTIONS (regardless of being valid or not).
    4836                 :          1 :     CBlockIndex* pindexFirstNotChainValid = nullptr; // Oldest ancestor of pindex which does not have BLOCK_VALID_CHAIN (regardless of being valid or not).
    4837                 :          1 :     CBlockIndex* pindexFirstNotScriptsValid = nullptr; // Oldest ancestor of pindex which does not have BLOCK_VALID_SCRIPTS (regardless of being valid or not).
    4838                 :          1 :     CBlockIndex* pindexFirstAssumeValid = nullptr; // Oldest ancestor of pindex which has BLOCK_ASSUMED_VALID
    4839         [ +  + ]:          2 :     while (pindex != nullptr) {
    4840                 :          1 :         nNodes++;
    4841   [ -  +  #  # ]:          1 :         if (pindex->pprev && pindex->nTx > 0) {
    4842                 :            :             // nChainTx should increase monotonically
    4843         [ #  # ]:          0 :             assert(pindex->pprev->nChainTx <= pindex->nChainTx);
    4844                 :          0 :         }
    4845   [ +  -  +  - ]:          1 :         if (pindexFirstAssumeValid == nullptr && pindex->nStatus & BLOCK_ASSUMED_VALID) pindexFirstAssumeValid = pindex;
    4846   [ +  -  +  - ]:          1 :         if (pindexFirstInvalid == nullptr && pindex->nStatus & BLOCK_FAILED_VALID) pindexFirstInvalid = pindex;
    4847   [ +  -  +  - ]:          1 :         if (pindexFirstMissing == nullptr && !(pindex->nStatus & BLOCK_HAVE_DATA)) {
    4848                 :          0 :             pindexFirstMissing = pindex;
    4849                 :          0 :         }
    4850   [ +  -  -  + ]:          1 :         if (pindexFirstNeverProcessed == nullptr && pindex->nTx == 0) pindexFirstNeverProcessed = pindex;
    4851   [ -  +  #  #  :          1 :         if (pindex->pprev != nullptr && pindexFirstNotTreeValid == nullptr && (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_TREE) pindexFirstNotTreeValid = pindex;
                   #  # ]
    4852                 :            : 
    4853   [ -  +  #  #  :          1 :         if (pindex->pprev != nullptr && !pindex->IsAssumedValid()) {
                   #  # ]
    4854                 :            :             // Skip validity flag checks for BLOCK_ASSUMED_VALID index entries, since these
    4855                 :            :             // *_VALID_MASK flags will not be present for index entries we are temporarily assuming
    4856                 :            :             // valid.
    4857   [ #  #  #  # ]:          0 :             if (pindexFirstNotTransactionsValid == nullptr &&
    4858                 :          0 :                     (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_TRANSACTIONS) {
    4859                 :          0 :                 pindexFirstNotTransactionsValid = pindex;
    4860                 :          0 :             }
    4861                 :            : 
    4862   [ #  #  #  # ]:          0 :             if (pindexFirstNotChainValid == nullptr &&
    4863                 :          0 :                     (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_CHAIN) {
    4864                 :          0 :                 pindexFirstNotChainValid = pindex;
    4865                 :          0 :             }
    4866                 :            : 
    4867   [ #  #  #  # ]:          0 :             if (pindexFirstNotScriptsValid == nullptr &&
    4868                 :          0 :                     (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_SCRIPTS) {
    4869                 :          0 :                 pindexFirstNotScriptsValid = pindex;
    4870                 :          0 :             }
    4871                 :          0 :         }
    4872                 :            : 
    4873                 :            :         // Begin: actual consistency checks.
    4874         [ +  - ]:          1 :         if (pindex->pprev == nullptr) {
    4875                 :            :             // Genesis block checks.
    4876   [ +  -  +  -  :          1 :             assert(pindex->GetBlockHash() == GetConsensus().hashGenesisBlock); // Genesis block's hash must match.
             +  -  +  - ]
    4877   [ +  -  +  + ]:          2 :             for (auto c : GetAll()) {
    4878   [ +  -  +  - ]:          1 :                 if (c->m_chain.Genesis() != nullptr) {
    4879   [ +  -  +  - ]:          1 :                     assert(pindex == c->m_chain.Genesis()); // The chain's genesis block must be this block.
    4880                 :          1 :                 }
    4881                 :            :             }
    4882                 :          1 :         }
    4883   [ +  -  +  -  :          1 :         if (!pindex->HaveTxsDownloaded()) assert(pindex->nSequenceId <= 0); // nSequenceId can't be set positive for blocks that aren't linked (negative is used for preciousblock)
                   #  # ]
    4884                 :            :         // VALID_TRANSACTIONS is equivalent to nTx > 0 for all nodes (whether or not pruning has occurred).
    4885                 :            :         // HAVE_DATA is only equivalent to nTx > 0 (or VALID_TRANSACTIONS) if no pruning has occurred.
    4886                 :            :         // Unless these indexes are assumed valid and pending block download on a
    4887                 :            :         // background chainstate.
    4888   [ +  -  +  -  :          1 :         if (!m_blockman.m_have_pruned && !pindex->IsAssumedValid()) {
                   -  + ]
    4889                 :            :             // If we've never pruned, then HAVE_DATA should be equivalent to nTx > 0
    4890         [ -  + ]:          1 :             assert(!(pindex->nStatus & BLOCK_HAVE_DATA) == (pindex->nTx == 0));
    4891         [ -  + ]:          1 :             if (pindexFirstAssumeValid == nullptr) {
    4892                 :            :                 // If we've got some assume valid blocks, then we might have
    4893                 :            :                 // missing blocks (not HAVE_DATA) but still treat them as
    4894                 :            :                 // having been processed (with a fake nTx value). Otherwise, we
    4895                 :            :                 // can assert that these are the same.
    4896         [ -  + ]:          1 :                 assert(pindexFirstMissing == pindexFirstNeverProcessed);
    4897                 :          1 :             }
    4898                 :          1 :         } else {
    4899                 :            :             // If we have pruned, then we can only say that HAVE_DATA implies nTx > 0
    4900   [ #  #  #  # ]:          0 :             if (pindex->nStatus & BLOCK_HAVE_DATA) assert(pindex->nTx > 0);
    4901                 :            :         }
    4902   [ +  -  #  # ]:          1 :         if (pindex->nStatus & BLOCK_HAVE_UNDO) assert(pindex->nStatus & BLOCK_HAVE_DATA);
    4903   [ +  -  -  + ]:          1 :         if (pindex->IsAssumedValid()) {
    4904                 :            :             // Assumed-valid blocks should have some nTx value.
    4905         [ #  # ]:          0 :             assert(pindex->nTx > 0);
    4906                 :            :             // Assumed-valid blocks should connect to the main chain.
    4907         [ #  # ]:          0 :             assert((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_TREE);
    4908                 :          0 :         } else {
    4909                 :            :             // Otherwise there should only be an nTx value if we have
    4910                 :            :             // actually seen a block's transactions.
    4911         [ +  - ]:          1 :             assert(((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_TRANSACTIONS) == (pindex->nTx > 0)); // This is pruning-independent.
    4912                 :            :         }
    4913                 :            :         // All parents having had data (at some point) is equivalent to all parents being VALID_TRANSACTIONS, which is equivalent to HaveTxsDownloaded().
    4914   [ +  -  +  - ]:          1 :         assert((pindexFirstNeverProcessed == nullptr) == pindex->HaveTxsDownloaded());
    4915   [ +  -  -  + ]:          1 :         assert((pindexFirstNotTransactionsValid == nullptr) == pindex->HaveTxsDownloaded());
    4916         [ -  + ]:          1 :         assert(pindex->nHeight == nHeight); // nHeight must be consistent.
    4917   [ -  +  #  #  :          1 :         assert(pindex->pprev == nullptr || pindex->nChainWork >= pindex->pprev->nChainWork); // For every block except the genesis block, the chainwork must be larger than the parent's.
                   -  + ]
    4918   [ +  -  #  #  :          1 :         assert(nHeight < 2 || (pindex->pskip && (pindex->pskip->nHeight < nHeight))); // The pskip pointer must point back for all but the first 2 blocks.
                   -  + ]
    4919         [ -  + ]:          1 :         assert(pindexFirstNotTreeValid == nullptr); // All m_blockman.m_block_index entries must at least be TREE valid
    4920   [ -  +  +  - ]:          1 :         if ((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_TREE) assert(pindexFirstNotTreeValid == nullptr); // TREE valid implies all parents are TREE valid
    4921   [ +  -  #  # ]:          1 :         if ((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_CHAIN) assert(pindexFirstNotChainValid == nullptr); // CHAIN valid implies all parents are CHAIN valid
    4922   [ +  -  #  # ]:          1 :         if ((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_SCRIPTS) assert(pindexFirstNotScriptsValid == nullptr); // SCRIPTS valid implies all parents are SCRIPTS valid
    4923         [ -  + ]:          1 :         if (pindexFirstInvalid == nullptr) {
    4924                 :            :             // Checks for not-invalid blocks.
    4925         [ +  - ]:          1 :             assert((pindex->nStatus & BLOCK_FAILED_MASK) == 0); // The failed mask cannot be set for blocks without invalid parents.
    4926                 :          1 :         }
    4927                 :            :         // Chainstate-specific checks on setBlockIndexCandidates
    4928   [ +  -  +  + ]:          2 :         for (auto c : GetAll()) {
    4929   [ +  -  +  - ]:          1 :             if (c->m_chain.Tip() == nullptr) continue;
    4930   [ +  -  +  -  :          1 :             if (!CBlockIndexWorkComparator()(pindex, c->m_chain.Tip()) && pindexFirstNeverProcessed == nullptr) {
             -  +  -  + ]
    4931         [ +  - ]:          1 :                 if (pindexFirstInvalid == nullptr) {
    4932         [ +  - ]:          1 :                     const bool is_active = c == &ActiveChainstate();
    4933                 :            :                     // If this block sorts at least as good as the current tip and
    4934                 :            :                     // is valid and we have all data for its parents, it must be in
    4935                 :            :                     // setBlockIndexCandidates.  m_chain.Tip() must also be there
    4936                 :            :                     // even if some data has been pruned.
    4937                 :            :                     //
    4938   [ -  +  #  #  :          1 :                     if ((pindexFirstMissing == nullptr || pindex == c->m_chain.Tip())) {
                   #  # ]
    4939                 :            :                         // The active chainstate should always have this block
    4940                 :            :                         // as a candidate, but a background chainstate should
    4941                 :            :                         // only have it if it is an ancestor of the snapshot base.
    4942   [ -  +  #  #  :          1 :                         if (is_active || GetSnapshotBaseBlock()->GetAncestor(pindex->nHeight) == pindex) {
             #  #  #  # ]
    4943   [ +  -  +  - ]:          1 :                             assert(c->setBlockIndexCandidates.count(pindex));
    4944                 :          1 :                         }
    4945                 :          1 :                     }
    4946                 :            :                     // If some parent is missing, then it could be that this block was in
    4947                 :            :                     // setBlockIndexCandidates but had to be removed because of the missing data.
    4948                 :            :                     // In this case it must be in m_blocks_unlinked -- see test below.
    4949                 :          1 :                 }
    4950                 :          1 :             } else { // If this block sorts worse than the current tip or some ancestor's block has never been seen, it cannot be in setBlockIndexCandidates.
    4951   [ #  #  #  # ]:          0 :                 assert(c->setBlockIndexCandidates.count(pindex) == 0);
    4952                 :            :             }
    4953                 :            :         }
    4954                 :            :         // Check whether this block is in m_blocks_unlinked.
    4955         [ +  - ]:          1 :         std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> rangeUnlinked = m_blockman.m_blocks_unlinked.equal_range(pindex->pprev);
    4956                 :          1 :         bool foundInUnlinked = false;
    4957         [ +  - ]:          1 :         while (rangeUnlinked.first != rangeUnlinked.second) {
    4958         [ #  # ]:          0 :             assert(rangeUnlinked.first->first == pindex->pprev);
    4959         [ #  # ]:          0 :             if (rangeUnlinked.first->second == pindex) {
    4960                 :          0 :                 foundInUnlinked = true;
    4961                 :          0 :                 break;
    4962                 :            :             }
    4963                 :          0 :             rangeUnlinked.first++;
    4964                 :            :         }
    4965   [ -  +  #  #  :          1 :         if (pindex->pprev && (pindex->nStatus & BLOCK_HAVE_DATA) && pindexFirstNeverProcessed != nullptr && pindexFirstInvalid == nullptr) {
             #  #  #  # ]
    4966                 :            :             // If this block has block data available, some parent was never received, and has no invalid parents, it must be in m_blocks_unlinked.
    4967         [ #  # ]:          0 :             assert(foundInUnlinked);
    4968                 :          0 :         }
    4969   [ +  -  #  # ]:          1 :         if (!(pindex->nStatus & BLOCK_HAVE_DATA)) assert(!foundInUnlinked); // Can't be in m_blocks_unlinked if we don't HAVE_DATA
    4970   [ -  +  +  - ]:          1 :         if (pindexFirstMissing == nullptr) assert(!foundInUnlinked); // We aren't missing data for any parent -- cannot be in m_blocks_unlinked.
    4971   [ -  +  #  #  :          1 :         if (pindex->pprev && (pindex->nStatus & BLOCK_HAVE_DATA) && pindexFirstNeverProcessed == nullptr && pindexFirstMissing != nullptr) {
             #  #  #  # ]
    4972                 :            :             // We HAVE_DATA for this block, have received data for all parents at some point, but we're currently missing data for some parent.
    4973   [ #  #  #  # ]:          0 :             assert(m_blockman.m_have_pruned || pindexFirstAssumeValid != nullptr); // We must have pruned, or else we're using a snapshot (causing us to have faked the received data for some parent(s)).
    4974                 :            :             // This block may have entered m_blocks_unlinked if:
    4975                 :            :             //  - it has a descendant that at some point had more work than the
    4976                 :            :             //    tip, and
    4977                 :            :             //  - we tried switching to that descendant but were missing
    4978                 :            :             //    data for some intermediate block between m_chain and the
    4979                 :            :             //    tip.
    4980                 :            :             // So if this block is itself better than any m_chain.Tip() and it wasn't in
    4981                 :            :             // setBlockIndexCandidates, then it must be in m_blocks_unlinked.
    4982   [ #  #  #  # ]:          0 :             for (auto c : GetAll()) {
    4983         [ #  # ]:          0 :                 const bool is_active = c == &ActiveChainstate();
    4984   [ #  #  #  #  :          0 :                 if (!CBlockIndexWorkComparator()(pindex, c->m_chain.Tip()) && c->setBlockIndexCandidates.count(pindex) == 0) {
          #  #  #  #  #  
                      # ]
    4985         [ #  # ]:          0 :                     if (pindexFirstInvalid == nullptr) {
    4986   [ #  #  #  #  :          0 :                         if (is_active || GetSnapshotBaseBlock()->GetAncestor(pindex->nHeight) == pindex) {
             #  #  #  # ]
    4987         [ #  # ]:          0 :                             assert(foundInUnlinked);
    4988                 :          0 :                         }
    4989                 :          0 :                     }
    4990                 :          0 :                 }
    4991                 :            :             }
    4992                 :          0 :         }
    4993                 :            :         // assert(pindex->GetBlockHash() == pindex->GetBlockHeader().GetHash()); // Perhaps too slow
    4994                 :            :         // End: actual consistency checks.
    4995                 :            : 
    4996                 :            :         // Try descending into the first subnode.
    4997         [ +  - ]:          1 :         std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> range = forward.equal_range(pindex);
    4998         [ -  + ]:          1 :         if (range.first != range.second) {
    4999                 :            :             // A subnode was found.
    5000                 :          0 :             pindex = range.first->second;
    5001                 :          0 :             nHeight++;
    5002                 :          0 :             continue;
    5003                 :            :         }
    5004                 :            :         // This is a leaf node.
    5005                 :            :         // Move upwards until we reach a node of which we have not yet visited the last child.
    5006         [ +  + ]:          2 :         while (pindex) {
    5007                 :            :             // We are going to either move to a parent or a sibling of pindex.
    5008                 :            :             // If pindex was the first with a certain property, unset the corresponding variable.
    5009         [ +  - ]:          1 :             if (pindex == pindexFirstInvalid) pindexFirstInvalid = nullptr;
    5010         [ +  - ]:          1 :             if (pindex == pindexFirstMissing) pindexFirstMissing = nullptr;
    5011         [ +  - ]:          1 :             if (pindex == pindexFirstNeverProcessed) pindexFirstNeverProcessed = nullptr;
    5012         [ +  - ]:          1 :             if (pindex == pindexFirstNotTreeValid) pindexFirstNotTreeValid = nullptr;
    5013         [ +  - ]:          1 :             if (pindex == pindexFirstNotTransactionsValid) pindexFirstNotTransactionsValid = nullptr;
    5014         [ +  - ]:          1 :             if (pindex == pindexFirstNotChainValid) pindexFirstNotChainValid = nullptr;
    5015         [ +  - ]:          1 :             if (pindex == pindexFirstNotScriptsValid) pindexFirstNotScriptsValid = nullptr;
    5016         [ +  - ]:          1 :             if (pindex == pindexFirstAssumeValid) pindexFirstAssumeValid = nullptr;
    5017                 :            :             // Find our parent.
    5018                 :          1 :             CBlockIndex* pindexPar = pindex->pprev;
    5019                 :            :             // Find which child we just visited.
    5020         [ +  - ]:          1 :             std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> rangePar = forward.equal_range(pindexPar);
    5021         [ -  + ]:          1 :             while (rangePar.first->second != pindex) {
    5022         [ #  # ]:          0 :                 assert(rangePar.first != rangePar.second); // Our parent must have at least the node we're coming from as child.
    5023                 :          0 :                 rangePar.first++;
    5024                 :            :             }
    5025                 :            :             // Proceed to the next one.
    5026                 :          1 :             rangePar.first++;
    5027         [ +  - ]:          1 :             if (rangePar.first != rangePar.second) {
    5028                 :            :                 // Move to the sibling.
    5029                 :          0 :                 pindex = rangePar.first->second;
    5030                 :          0 :                 break;
    5031                 :            :             } else {
    5032                 :            :                 // Move up further.
    5033                 :          1 :                 pindex = pindexPar;
    5034                 :          1 :                 nHeight--;
    5035                 :          1 :                 continue;
    5036                 :            :             }
    5037                 :            :         }
    5038                 :            :     }
    5039                 :            : 
    5040                 :            :     // Check that we actually traversed the entire map.
    5041         [ +  - ]:          1 :     assert(nNodes == forward.size());
    5042         [ -  + ]:          1 : }
    5043                 :            : 
    5044                 :          3 : std::string Chainstate::ToString()
    5045                 :            : {
    5046                 :          3 :     AssertLockHeld(::cs_main);
    5047                 :          3 :     CBlockIndex* tip = m_chain.Tip();
    5048   [ +  -  -  +  :          3 :     return strprintf("Chainstate [%s] @ height %d (%s)",
                   #  # ]
    5049                 :          3 :                      m_from_snapshot_blockhash ? "snapshot" : "ibd",
    5050   [ +  -  -  +  :          3 :                      tip ? tip->nHeight : -1, tip ? tip->GetBlockHash().ToString() : "null");
                   +  - ]
    5051                 :          0 : }
    5052                 :            : 
    5053                 :          1 : bool Chainstate::ResizeCoinsCaches(size_t coinstip_size, size_t coinsdb_size)
    5054                 :            : {
    5055                 :          1 :     AssertLockHeld(::cs_main);
    5056   [ -  +  #  # ]:          1 :     if (coinstip_size == m_coinstip_cache_size_bytes &&
    5057                 :          0 :             coinsdb_size == m_coinsdb_cache_size_bytes) {
    5058                 :            :         // Cache sizes are unchanged, no need to continue.
    5059                 :          0 :         return true;
    5060                 :            :     }
    5061                 :          1 :     size_t old_coinstip_size = m_coinstip_cache_size_bytes;
    5062                 :          1 :     m_coinstip_cache_size_bytes = coinstip_size;
    5063                 :          1 :     m_coinsdb_cache_size_bytes = coinsdb_size;
    5064                 :          1 :     CoinsDB().ResizeCache(coinsdb_size);
    5065                 :            : 
    5066   [ +  -  +  -  :          1 :     LogPrintf("[%s] resized coinsdb cache to %.1f MiB\n",
             +  -  +  - ]
    5067                 :            :         this->ToString(), coinsdb_size * (1.0 / 1024 / 1024));
    5068   [ +  -  +  -  :          1 :     LogPrintf("[%s] resized coinstip cache to %.1f MiB\n",
             +  -  +  - ]
    5069                 :            :         this->ToString(), coinstip_size * (1.0 / 1024 / 1024));
    5070                 :            : 
    5071                 :          1 :     BlockValidationState state;
    5072                 :            :     bool ret;
    5073                 :            : 
    5074         [ -  + ]:          1 :     if (coinstip_size > old_coinstip_size) {
    5075                 :            :         // Likely no need to flush if cache sizes have grown.
    5076         [ +  - ]:          1 :         ret = FlushStateToDisk(state, FlushStateMode::IF_NEEDED);
    5077                 :          1 :     } else {
    5078                 :            :         // Otherwise, flush state to disk and deallocate the in-memory coins map.
    5079         [ #  # ]:          0 :         ret = FlushStateToDisk(state, FlushStateMode::ALWAYS);
    5080                 :            :     }
    5081                 :          1 :     return ret;
    5082                 :          1 : }
    5083                 :            : 
    5084                 :            : //! Guess how far we are in the verification process at the given block index
    5085                 :            : //! require cs_main if pindex has not been validated yet (because nChainTx might be unset)
    5086                 :          1 : double GuessVerificationProgress(const ChainTxData& data, const CBlockIndex *pindex) {
    5087         [ +  - ]:          1 :     if (pindex == nullptr)
    5088                 :          0 :         return 0.0;
    5089                 :            : 
    5090                 :          1 :     int64_t nNow = time(nullptr);
    5091                 :            : 
    5092                 :            :     double fTxTotal;
    5093                 :            : 
    5094         [ -  + ]:          1 :     if (pindex->nChainTx <= data.nTxCount) {
    5095                 :          0 :         fTxTotal = data.nTxCount + (nNow - data.nTime) * data.dTxRate;
    5096                 :          0 :     } else {
    5097                 :          1 :         fTxTotal = pindex->nChainTx + (nNow - pindex->GetBlockTime()) * data.dTxRate;
    5098                 :            :     }
    5099                 :            : 
    5100                 :          1 :     return std::min<double>(pindex->nChainTx / fTxTotal, 1.0);
    5101                 :          1 : }
    5102                 :            : 
    5103                 :          1 : std::optional<uint256> ChainstateManager::SnapshotBlockhash() const
    5104                 :            : {
    5105                 :          1 :     LOCK(::cs_main);
    5106   [ +  -  -  + ]:          1 :     if (m_active_chainstate && m_active_chainstate->m_from_snapshot_blockhash) {
    5107                 :            :         // If a snapshot chainstate exists, it will always be our active.
    5108                 :          0 :         return m_active_chainstate->m_from_snapshot_blockhash;
    5109                 :            :     }
    5110                 :          1 :     return std::nullopt;
    5111                 :          1 : }
    5112                 :            : 
    5113                 :          7 : std::vector<Chainstate*> ChainstateManager::GetAll()
    5114                 :            : {
    5115                 :          7 :     LOCK(::cs_main);
    5116                 :          7 :     std::vector<Chainstate*> out;
    5117                 :            : 
    5118         [ +  + ]:         21 :     for (Chainstate* cs : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) {
    5119   [ +  -  +  +  :         14 :         if (this->IsUsable(cs)) out.push_back(cs);
                   +  - ]
    5120                 :            :     }
    5121                 :            : 
    5122                 :          7 :     return out;
    5123         [ +  - ]:          7 : }
    5124                 :            : 
    5125                 :          1 : Chainstate& ChainstateManager::InitializeChainstate(CTxMemPool* mempool)
    5126                 :            : {
    5127                 :          1 :     AssertLockHeld(::cs_main);
    5128         [ +  - ]:          1 :     assert(!m_ibd_chainstate);
    5129         [ +  - ]:          1 :     assert(!m_active_chainstate);
    5130                 :            : 
    5131                 :          1 :     m_ibd_chainstate = std::make_unique<Chainstate>(mempool, m_blockman, *this);
    5132                 :          1 :     m_active_chainstate = m_ibd_chainstate.get();
    5133                 :          1 :     return *m_active_chainstate;
    5134                 :            : }
    5135                 :            : 
    5136                 :          0 : [[nodiscard]] static bool DeleteCoinsDBFromDisk(const fs::path db_path, bool is_snapshot)
    5137                 :            :     EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
    5138                 :            : {
    5139                 :          0 :     AssertLockHeld(::cs_main);
    5140                 :            : 
    5141         [ #  # ]:          0 :     if (is_snapshot) {
    5142   [ #  #  #  # ]:          0 :         fs::path base_blockhash_path = db_path / node::SNAPSHOT_BLOCKHASH_FILENAME;
    5143                 :            : 
    5144                 :            :         try {
    5145         [ #  # ]:          0 :             bool existed = fs::remove(base_blockhash_path);
    5146         [ #  # ]:          0 :             if (!existed) {
    5147   [ #  #  #  #  :          0 :                 LogPrintf("[snapshot] snapshot chainstate dir being removed lacks %s file\n",
             #  #  #  # ]
    5148                 :            :                           fs::PathToString(node::SNAPSHOT_BLOCKHASH_FILENAME));
    5149                 :          0 :             }
    5150         [ #  # ]:          0 :         } catch (const fs::filesystem_error& e) {
    5151   [ #  #  #  #  :          0 :             LogPrintf("[snapshot] failed to remove file %s: %s\n",
          #  #  #  #  #  
                      # ]
    5152                 :            :                     fs::PathToString(base_blockhash_path), fsbridge::get_filesystem_error_message(e));
    5153   [ #  #  #  # ]:          0 :         }
    5154                 :          0 :     }
    5155                 :            : 
    5156                 :          0 :     std::string path_str = fs::PathToString(db_path);
    5157   [ #  #  #  #  :          0 :     LogPrintf("Removing leveldb dir at %s\n", path_str);
                   #  # ]
    5158                 :            : 
    5159                 :            :     // We have to destruct before this call leveldb::DB in order to release the db
    5160                 :            :     // lock, otherwise `DestroyDB` will fail. See `leveldb::~DBImpl()`.
    5161         [ #  # ]:          0 :     const bool destroyed = DestroyDB(path_str);
    5162                 :            : 
    5163         [ #  # ]:          0 :     if (!destroyed) {
    5164   [ #  #  #  #  :          0 :         LogPrintf("error: leveldb DestroyDB call failed on %s\n", path_str);
                   #  # ]
    5165                 :          0 :     }
    5166                 :            : 
    5167                 :            :     // Datadir should be removed from filesystem; otherwise initialization may detect
    5168                 :            :     // it on subsequent statups and get confused.
    5169                 :            :     //
    5170                 :            :     // If the base_blockhash_path removal above fails in the case of snapshot
    5171                 :            :     // chainstates, this will return false since leveldb won't remove a non-empty
    5172                 :            :     // directory.
    5173   [ #  #  #  # ]:          0 :     return destroyed && !fs::exists(db_path);
    5174                 :          0 : }
    5175                 :            : 
    5176                 :          0 : bool ChainstateManager::ActivateSnapshot(
    5177                 :            :         AutoFile& coins_file,
    5178                 :            :         const SnapshotMetadata& metadata,
    5179                 :            :         bool in_memory)
    5180                 :            : {
    5181                 :          0 :     uint256 base_blockhash = metadata.m_base_blockhash;
    5182                 :            : 
    5183         [ #  # ]:          0 :     if (this->SnapshotBlockhash()) {
    5184   [ #  #  #  #  :          0 :         LogPrintf("[snapshot] can't activate a snapshot-based chainstate more than once\n");
                   #  # ]
    5185                 :          0 :         return false;
    5186                 :            :     }
    5187                 :            : 
    5188                 :            :     {
    5189                 :          0 :         LOCK(::cs_main);
    5190   [ #  #  #  #  :          0 :         if (Assert(m_active_chainstate->GetMempool())->size() > 0) {
             #  #  #  # ]
    5191   [ #  #  #  #  :          0 :             LogPrintf("[snapshot] can't activate a snapshot when mempool not empty\n");
                   #  # ]
    5192                 :          0 :             return false;
    5193                 :            :         }
    5194      [ #  #  # ]:          0 :     }
    5195                 :            : 
    5196                 :          0 :     int64_t current_coinsdb_cache_size{0};
    5197                 :          0 :     int64_t current_coinstip_cache_size{0};
    5198                 :            : 
    5199                 :            :     // Cache percentages to allocate to each chainstate.
    5200                 :            :     //
    5201                 :            :     // These particular percentages don't matter so much since they will only be
    5202                 :            :     // relevant during snapshot activation; caches are rebalanced at the conclusion of
    5203                 :            :     // this function. We want to give (essentially) all available cache capacity to the
    5204                 :            :     // snapshot to aid the bulk load later in this function.
    5205                 :            :     static constexpr double IBD_CACHE_PERC = 0.01;
    5206                 :            :     static constexpr double SNAPSHOT_CACHE_PERC = 0.99;
    5207                 :            : 
    5208                 :            :     {
    5209                 :          0 :         LOCK(::cs_main);
    5210                 :            :         // Resize the coins caches to ensure we're not exceeding memory limits.
    5211                 :            :         //
    5212                 :            :         // Allocate the majority of the cache to the incoming snapshot chainstate, since
    5213                 :            :         // (optimistically) getting to its tip will be the top priority. We'll need to call
    5214                 :            :         // `MaybeRebalanceCaches()` once we're done with this function to ensure
    5215                 :            :         // the right allocation (including the possibility that no snapshot was activated
    5216                 :            :         // and that we should restore the active chainstate caches to their original size).
    5217                 :            :         //
    5218         [ #  # ]:          0 :         current_coinsdb_cache_size = this->ActiveChainstate().m_coinsdb_cache_size_bytes;
    5219         [ #  # ]:          0 :         current_coinstip_cache_size = this->ActiveChainstate().m_coinstip_cache_size_bytes;
    5220                 :            : 
    5221                 :            :         // Temporarily resize the active coins cache to make room for the newly-created
    5222                 :            :         // snapshot chain.
    5223   [ #  #  #  # ]:          0 :         this->ActiveChainstate().ResizeCoinsCaches(
    5224                 :          0 :             static_cast<size_t>(current_coinstip_cache_size * IBD_CACHE_PERC),
    5225                 :          0 :             static_cast<size_t>(current_coinsdb_cache_size * IBD_CACHE_PERC));
    5226                 :          0 :     }
    5227                 :            : 
    5228         [ #  # ]:          0 :     auto snapshot_chainstate = WITH_LOCK(::cs_main,
    5229                 :            :         return std::make_unique<Chainstate>(
    5230                 :            :             /*mempool=*/nullptr, m_blockman, *this, base_blockhash));
    5231                 :            : 
    5232                 :            :     {
    5233   [ #  #  #  # ]:          0 :         LOCK(::cs_main);
    5234         [ #  # ]:          0 :         snapshot_chainstate->InitCoinsDB(
    5235                 :          0 :             static_cast<size_t>(current_coinsdb_cache_size * SNAPSHOT_CACHE_PERC),
    5236         [ #  # ]:          0 :             in_memory, false, "chainstate");
    5237   [ #  #  #  # ]:          0 :         snapshot_chainstate->InitCoinsCache(
    5238                 :          0 :             static_cast<size_t>(current_coinstip_cache_size * SNAPSHOT_CACHE_PERC));
    5239                 :          0 :     }
    5240                 :            : 
    5241                 :          0 :     auto cleanup_bad_snapshot = [&](const char* reason) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
    5242   [ #  #  #  #  :          0 :         LogPrintf("[snapshot] activation failed - %s\n", reason);
                   #  # ]
    5243                 :          0 :         this->MaybeRebalanceCaches();
    5244                 :            : 
    5245                 :            :         // PopulateAndValidateSnapshot can return (in error) before the leveldb datadir
    5246                 :            :         // has been created, so only attempt removal if we got that far.
    5247         [ #  # ]:          0 :         if (auto snapshot_datadir = node::FindSnapshotChainstateDir(m_options.datadir)) {
    5248                 :            :             // We have to destruct leveldb::DB in order to release the db lock, otherwise
    5249                 :            :             // DestroyDB() (in DeleteCoinsDBFromDisk()) will fail. See `leveldb::~DBImpl()`.
    5250                 :            :             // Destructing the chainstate (and so resetting the coinsviews object) does this.
    5251                 :          0 :             snapshot_chainstate.reset();
    5252   [ #  #  #  #  :          0 :             bool removed = DeleteCoinsDBFromDisk(*snapshot_datadir, /*is_snapshot=*/true);
                   #  # ]
    5253         [ #  # ]:          0 :             if (!removed) {
    5254   [ #  #  #  # ]:          0 :                 GetNotifications().fatalError(strprintf("Failed to remove snapshot chainstate dir (%s). "
    5255   [ #  #  #  # ]:          0 :                     "Manually remove it before restarting.\n", fs::PathToString(*snapshot_datadir)));
    5256                 :          0 :             }
    5257                 :          0 :         }
    5258                 :          0 :         return false;
    5259                 :          0 :     };
    5260                 :            : 
    5261   [ #  #  #  #  :          0 :     if (!this->PopulateAndValidateSnapshot(*snapshot_chainstate, coins_file, metadata)) {
                   #  # ]
    5262   [ #  #  #  # ]:          0 :         LOCK(::cs_main);
    5263         [ #  # ]:          0 :         return cleanup_bad_snapshot("population failed");
    5264                 :          0 :     }
    5265                 :            : 
    5266   [ #  #  #  # ]:          0 :     LOCK(::cs_main);  // cs_main required for rest of snapshot activation.
    5267                 :            : 
    5268                 :            :     // Do a final check to ensure that the snapshot chainstate is actually a more
    5269                 :            :     // work chain than the active chainstate; a user could have loaded a snapshot
    5270                 :            :     // very late in the IBD process, and we wouldn't want to load a useless chainstate.
    5271   [ #  #  #  #  :          0 :     if (!CBlockIndexWorkComparator()(ActiveTip(), snapshot_chainstate->m_chain.Tip())) {
             #  #  #  # ]
    5272         [ #  # ]:          0 :         return cleanup_bad_snapshot("work does not exceed active chainstate");
    5273                 :            :     }
    5274                 :            :     // If not in-memory, persist the base blockhash for use during subsequent
    5275                 :            :     // initialization.
    5276         [ #  # ]:          0 :     if (!in_memory) {
    5277   [ #  #  #  #  :          0 :         if (!node::WriteSnapshotBaseBlockhash(*snapshot_chainstate)) {
                   #  # ]
    5278         [ #  # ]:          0 :             return cleanup_bad_snapshot("could not write base blockhash");
    5279                 :            :         }
    5280                 :          0 :     }
    5281                 :            : 
    5282         [ #  # ]:          0 :     assert(!m_snapshot_chainstate);
    5283                 :          0 :     m_snapshot_chainstate.swap(snapshot_chainstate);
    5284         [ #  # ]:          0 :     const bool chaintip_loaded = m_snapshot_chainstate->LoadChainTip();
    5285         [ #  # ]:          0 :     assert(chaintip_loaded);
    5286                 :            : 
    5287                 :            :     // Transfer possession of the mempool to the snapshot chainstate.
    5288                 :            :     // Mempool is empty at this point because we're still in IBD.
    5289   [ #  #  #  # ]:          0 :     Assert(m_active_chainstate->m_mempool->size() == 0);
    5290         [ #  # ]:          0 :     Assert(!m_snapshot_chainstate->m_mempool);
    5291                 :          0 :     m_snapshot_chainstate->m_mempool = m_active_chainstate->m_mempool;
    5292                 :          0 :     m_active_chainstate->m_mempool = nullptr;
    5293                 :          0 :     m_active_chainstate = m_snapshot_chainstate.get();
    5294         [ #  # ]:          0 :     m_blockman.m_snapshot_height = this->GetSnapshotBaseHeight();
    5295                 :            : 
    5296   [ #  #  #  #  :          0 :     LogPrintf("[snapshot] successfully activated snapshot %s\n", base_blockhash.ToString());
             #  #  #  # ]
    5297   [ #  #  #  #  :          0 :     LogPrintf("[snapshot] (%.2f MB)\n",
          #  #  #  #  #  
                      # ]
    5298                 :            :         m_snapshot_chainstate->CoinsTip().DynamicMemoryUsage() / (1000 * 1000));
    5299                 :            : 
    5300         [ #  # ]:          0 :     this->MaybeRebalanceCaches();
    5301                 :          0 :     return true;
    5302                 :          0 : }
    5303                 :            : 
    5304                 :          0 : static void FlushSnapshotToDisk(CCoinsViewCache& coins_cache, bool snapshot_loaded)
    5305                 :            : {
    5306   [ #  #  #  #  :          0 :     LOG_TIME_MILLIS_WITH_CATEGORY_MSG_ONCE(
             #  #  #  # ]
    5307                 :            :         strprintf("%s (%.2f MB)",
    5308                 :            :                   snapshot_loaded ? "saving snapshot chainstate" : "flushing coins cache",
    5309                 :            :                   coins_cache.DynamicMemoryUsage() / (1000 * 1000)),
    5310                 :            :         BCLog::LogFlags::ALL);
    5311                 :            : 
    5312         [ #  # ]:          0 :     coins_cache.Flush();
    5313                 :          0 : }
    5314                 :            : 
    5315                 :            : struct StopHashingException : public std::exception
    5316                 :            : {
    5317                 :          0 :     const char* what() const noexcept override
    5318                 :            :     {
    5319                 :          0 :         return "ComputeUTXOStats interrupted.";
    5320                 :            :     }
    5321                 :            : };
    5322                 :            : 
    5323                 :          0 : static void SnapshotUTXOHashBreakpoint(const util::SignalInterrupt& interrupt)
    5324                 :            : {
    5325         [ #  # ]:          0 :     if (interrupt) throw StopHashingException();
    5326                 :          0 : }
    5327                 :            : 
    5328                 :          0 : bool ChainstateManager::PopulateAndValidateSnapshot(
    5329                 :            :     Chainstate& snapshot_chainstate,
    5330                 :            :     AutoFile& coins_file,
    5331                 :            :     const SnapshotMetadata& metadata)
    5332                 :            : {
    5333                 :            :     // It's okay to release cs_main before we're done using `coins_cache` because we know
    5334                 :            :     // that nothing else will be referencing the newly created snapshot_chainstate yet.
    5335         [ #  # ]:          0 :     CCoinsViewCache& coins_cache = *WITH_LOCK(::cs_main, return &snapshot_chainstate.CoinsTip());
    5336                 :            : 
    5337                 :          0 :     uint256 base_blockhash = metadata.m_base_blockhash;
    5338                 :            : 
    5339         [ #  # ]:          0 :     CBlockIndex* snapshot_start_block = WITH_LOCK(::cs_main, return m_blockman.LookupBlockIndex(base_blockhash));
    5340                 :            : 
    5341         [ #  # ]:          0 :     if (!snapshot_start_block) {
    5342                 :            :         // Needed for ComputeUTXOStats to determine the
    5343                 :            :         // height and to avoid a crash when base_blockhash.IsNull()
    5344   [ #  #  #  #  :          0 :         LogPrintf("[snapshot] Did not find snapshot start blockheader %s\n",
             #  #  #  # ]
    5345                 :            :                   base_blockhash.ToString());
    5346                 :          0 :         return false;
    5347                 :            :     }
    5348                 :            : 
    5349                 :          0 :     int base_height = snapshot_start_block->nHeight;
    5350                 :          0 :     const auto& maybe_au_data = GetParams().AssumeutxoForHeight(base_height);
    5351                 :            : 
    5352         [ #  # ]:          0 :     if (!maybe_au_data) {
    5353   [ #  #  #  #  :          0 :         LogPrintf("[snapshot] assumeutxo height in snapshot metadata not recognized "
                   #  # ]
    5354                 :            :                   "(%d) - refusing to load snapshot\n", base_height);
    5355                 :          0 :         return false;
    5356                 :            :     }
    5357                 :            : 
    5358                 :          0 :     const AssumeutxoData& au_data = *maybe_au_data;
    5359                 :            : 
    5360                 :            :     // This work comparison is a duplicate check with the one performed later in
    5361                 :            :     // ActivateSnapshot(), but is done so that we avoid doing the long work of staging
    5362                 :            :     // a snapshot that isn't actually usable.
    5363   [ #  #  #  #  :          0 :     if (WITH_LOCK(::cs_main, return !CBlockIndexWorkComparator()(ActiveTip(), snapshot_start_block))) {
                   #  # ]
    5364   [ #  #  #  #  :          0 :         LogPrintf("[snapshot] activation failed - height does not exceed active chainstate\n");
                   #  # ]
    5365                 :          0 :         return false;
    5366                 :            :     }
    5367                 :            : 
    5368                 :          0 :     COutPoint outpoint;
    5369                 :          0 :     Coin coin;
    5370                 :          0 :     const uint64_t coins_count = metadata.m_coins_count;
    5371                 :          0 :     uint64_t coins_left = metadata.m_coins_count;
    5372                 :            : 
    5373   [ #  #  #  #  :          0 :     LogPrintf("[snapshot] loading coins from snapshot %s\n", base_blockhash.ToString());
             #  #  #  # ]
    5374                 :          0 :     int64_t coins_processed{0};
    5375                 :            : 
    5376         [ #  # ]:          0 :     while (coins_left > 0) {
    5377                 :            :         try {
    5378         [ #  # ]:          0 :             coins_file >> outpoint;
    5379         [ #  # ]:          0 :             coins_file >> coin;
    5380         [ #  # ]:          0 :         } catch (const std::ios_base::failure&) {
    5381   [ #  #  #  #  :          0 :             LogPrintf("[snapshot] bad snapshot format or truncated snapshot after deserializing %d coins\n",
                   #  # ]
    5382                 :            :                       coins_count - coins_left);
    5383                 :          0 :             return false;
    5384   [ #  #  #  # ]:          0 :         }
    5385         [ #  # ]:          0 :         if (coin.nHeight > base_height ||
    5386                 :          0 :             outpoint.n >= std::numeric_limits<decltype(outpoint.n)>::max() // Avoid integer wrap-around in coinstats.cpp:ApplyHash
    5387                 :            :         ) {
    5388   [ #  #  #  #  :          0 :             LogPrintf("[snapshot] bad snapshot data after deserializing %d coins\n",
                   #  # ]
    5389                 :            :                       coins_count - coins_left);
    5390                 :          0 :             return false;
    5391                 :            :         }
    5392                 :            : 
    5393         [ #  # ]:          0 :         coins_cache.EmplaceCoinInternalDANGER(std::move(outpoint), std::move(coin));
    5394                 :            : 
    5395                 :          0 :         --coins_left;
    5396                 :          0 :         ++coins_processed;
    5397                 :            : 
    5398         [ #  # ]:          0 :         if (coins_processed % 1000000 == 0) {
    5399   [ #  #  #  #  :          0 :             LogPrintf("[snapshot] %d coins loaded (%.2f%%, %.2f MB)\n",
             #  #  #  # ]
    5400                 :            :                 coins_processed,
    5401                 :            :                 static_cast<float>(coins_processed) * 100 / static_cast<float>(coins_count),
    5402                 :            :                 coins_cache.DynamicMemoryUsage() / (1000 * 1000));
    5403                 :          0 :         }
    5404                 :            : 
    5405                 :            :         // Batch write and flush (if we need to) every so often.
    5406                 :            :         //
    5407                 :            :         // If our average Coin size is roughly 41 bytes, checking every 120,000 coins
    5408                 :            :         // means <5MB of memory imprecision.
    5409         [ #  # ]:          0 :         if (coins_processed % 120000 == 0) {
    5410   [ #  #  #  # ]:          0 :             if (m_interrupt) {
    5411                 :          0 :                 return false;
    5412                 :            :             }
    5413                 :            : 
    5414   [ #  #  #  #  :          0 :             const auto snapshot_cache_state = WITH_LOCK(::cs_main,
                   #  # ]
    5415                 :            :                 return snapshot_chainstate.GetCoinsCacheSizeState());
    5416                 :            : 
    5417         [ #  # ]:          0 :             if (snapshot_cache_state >= CoinsCacheSizeState::CRITICAL) {
    5418                 :            :                 // This is a hack - we don't know what the actual best block is, but that
    5419                 :            :                 // doesn't matter for the purposes of flushing the cache here. We'll set this
    5420                 :            :                 // to its correct value (`base_blockhash`) below after the coins are loaded.
    5421         [ #  # ]:          0 :                 coins_cache.SetBestBlock(GetRandHash());
    5422                 :            : 
    5423                 :            :                 // No need to acquire cs_main since this chainstate isn't being used yet.
    5424         [ #  # ]:          0 :                 FlushSnapshotToDisk(coins_cache, /*snapshot_loaded=*/false);
    5425                 :          0 :             }
    5426                 :          0 :         }
    5427                 :            :     }
    5428                 :            : 
    5429                 :            :     // Important that we set this. This and the coins_cache accesses above are
    5430                 :            :     // sort of a layer violation, but either we reach into the innards of
    5431                 :            :     // CCoinsViewCache here or we have to invert some of the Chainstate to
    5432                 :            :     // embed them in a snapshot-activation-specific CCoinsViewCache bulk load
    5433                 :            :     // method.
    5434         [ #  # ]:          0 :     coins_cache.SetBestBlock(base_blockhash);
    5435                 :            : 
    5436                 :          0 :     bool out_of_coins{false};
    5437                 :            :     try {
    5438         [ #  # ]:          0 :         coins_file >> outpoint;
    5439         [ #  # ]:          0 :     } catch (const std::ios_base::failure&) {
    5440                 :            :         // We expect an exception since we should be out of coins.
    5441                 :          0 :         out_of_coins = true;
    5442         [ #  # ]:          0 :     }
    5443         [ #  # ]:          0 :     if (!out_of_coins) {
    5444   [ #  #  #  #  :          0 :         LogPrintf("[snapshot] bad snapshot - coins left over after deserializing %d coins\n",
                   #  # ]
    5445                 :            :             coins_count);
    5446                 :          0 :         return false;
    5447                 :            :     }
    5448                 :            : 
    5449   [ #  #  #  #  :          0 :     LogPrintf("[snapshot] loaded %d (%.2f MB) coins from snapshot %s\n",
          #  #  #  #  #  
                      # ]
    5450                 :            :         coins_count,
    5451                 :            :         coins_cache.DynamicMemoryUsage() / (1000 * 1000),
    5452                 :            :         base_blockhash.ToString());
    5453                 :            : 
    5454                 :            :     // No need to acquire cs_main since this chainstate isn't being used yet.
    5455         [ #  # ]:          0 :     FlushSnapshotToDisk(coins_cache, /*snapshot_loaded=*/true);
    5456                 :            : 
    5457   [ #  #  #  #  :          0 :     assert(coins_cache.GetBestBlock() == base_blockhash);
                   #  # ]
    5458                 :            : 
    5459                 :            :     // As above, okay to immediately release cs_main here since no other context knows
    5460                 :            :     // about the snapshot_chainstate.
    5461   [ #  #  #  #  :          0 :     CCoinsViewDB* snapshot_coinsdb = WITH_LOCK(::cs_main, return &snapshot_chainstate.CoinsDB());
                   #  # ]
    5462                 :            : 
    5463                 :          0 :     std::optional<CCoinsStats> maybe_stats;
    5464                 :            : 
    5465                 :            :     try {
    5466         [ #  # ]:          0 :         maybe_stats = ComputeUTXOStats(
    5467         [ #  # ]:          0 :             CoinStatsHashType::HASH_SERIALIZED, snapshot_coinsdb, m_blockman, [&interrupt = m_interrupt] { SnapshotUTXOHashBreakpoint(interrupt); });
    5468         [ #  # ]:          0 :     } catch (StopHashingException const&) {
    5469                 :          0 :         return false;
    5470         [ #  # ]:          0 :     }
    5471         [ #  # ]:          0 :     if (!maybe_stats.has_value()) {
    5472   [ #  #  #  #  :          0 :         LogPrintf("[snapshot] failed to generate coins stats\n");
                   #  # ]
    5473                 :          0 :         return false;
    5474                 :            :     }
    5475                 :            : 
    5476                 :            :     // Assert that the deserialized chainstate contents match the expected assumeutxo value.
    5477   [ #  #  #  #  :          0 :     if (AssumeutxoHash{maybe_stats->hashSerialized} != au_data.hash_serialized) {
                   #  # ]
    5478   [ #  #  #  #  :          0 :         LogPrintf("[snapshot] bad snapshot content hash: expected %s, got %s\n",
          #  #  #  #  #  
                #  #  # ]
    5479                 :            :             au_data.hash_serialized.ToString(), maybe_stats->hashSerialized.ToString());
    5480                 :          0 :         return false;
    5481                 :            :     }
    5482                 :            : 
    5483         [ #  # ]:          0 :     snapshot_chainstate.m_chain.SetTip(*snapshot_start_block);
    5484                 :            : 
    5485                 :            :     // The remainder of this function requires modifying data protected by cs_main.
    5486   [ #  #  #  # ]:          0 :     LOCK(::cs_main);
    5487                 :            : 
    5488                 :            :     // Fake various pieces of CBlockIndex state:
    5489                 :          0 :     CBlockIndex* index = nullptr;
    5490                 :            : 
    5491                 :            :     // Don't make any modifications to the genesis block.
    5492                 :            :     // This is especially important because we don't want to erroneously
    5493                 :            :     // apply BLOCK_ASSUMED_VALID to genesis, which would happen if we didn't skip
    5494                 :            :     // it here (since it apparently isn't BLOCK_VALID_SCRIPTS).
    5495                 :          0 :     constexpr int AFTER_GENESIS_START{1};
    5496                 :            : 
    5497   [ #  #  #  # ]:          0 :     for (int i = AFTER_GENESIS_START; i <= snapshot_chainstate.m_chain.Height(); ++i) {
    5498         [ #  # ]:          0 :         index = snapshot_chainstate.m_chain[i];
    5499                 :            : 
    5500                 :            :         // Fake nTx so that LoadBlockIndex() loads assumed-valid CBlockIndex
    5501                 :            :         // entries (among other things)
    5502         [ #  # ]:          0 :         if (!index->nTx) {
    5503                 :          0 :             index->nTx = 1;
    5504                 :          0 :         }
    5505                 :            :         // Fake nChainTx so that GuessVerificationProgress reports accurately
    5506                 :          0 :         index->nChainTx = index->pprev->nChainTx + index->nTx;
    5507                 :            : 
    5508                 :            :         // Mark unvalidated block index entries beneath the snapshot base block as assumed-valid.
    5509   [ #  #  #  # ]:          0 :         if (!index->IsValid(BLOCK_VALID_SCRIPTS)) {
    5510                 :            :             // This flag will be removed once the block is fully validated by a
    5511                 :            :             // background chainstate.
    5512                 :          0 :             index->nStatus |= BLOCK_ASSUMED_VALID;
    5513                 :          0 :         }
    5514                 :            : 
    5515                 :            :         // Fake BLOCK_OPT_WITNESS so that Chainstate::NeedsRedownload()
    5516                 :            :         // won't ask to rewind the entire assumed-valid chain on startup.
    5517   [ #  #  #  # ]:          0 :         if (DeploymentActiveAt(*index, *this, Consensus::DEPLOYMENT_SEGWIT)) {
    5518                 :          0 :             index->nStatus |= BLOCK_OPT_WITNESS;
    5519                 :          0 :         }
    5520                 :            : 
    5521         [ #  # ]:          0 :         m_blockman.m_dirty_blockindex.insert(index);
    5522                 :            :         // Changes to the block index will be flushed to disk after this call
    5523                 :            :         // returns in `ActivateSnapshot()`, when `MaybeRebalanceCaches()` is
    5524                 :            :         // called, since we've added a snapshot chainstate and therefore will
    5525                 :            :         // have to downsize the IBD chainstate, which will result in a call to
    5526                 :            :         // `FlushStateToDisk(ALWAYS)`.
    5527                 :          0 :     }
    5528                 :            : 
    5529         [ #  # ]:          0 :     assert(index);
    5530                 :          0 :     index->nChainTx = au_data.nChainTx;
    5531         [ #  # ]:          0 :     snapshot_chainstate.setBlockIndexCandidates.insert(snapshot_start_block);
    5532                 :            : 
    5533   [ #  #  #  #  :          0 :     LogPrintf("[snapshot] validated snapshot (%.2f MB)\n",
             #  #  #  # ]
    5534                 :            :         coins_cache.DynamicMemoryUsage() / (1000 * 1000));
    5535                 :          0 :     return true;
    5536                 :          0 : }
    5537                 :            : 
    5538                 :            : // Currently, this function holds cs_main for its duration, which could be for
    5539                 :            : // multiple minutes due to the ComputeUTXOStats call. This hold is necessary
    5540                 :            : // because we need to avoid advancing the background validation chainstate
    5541                 :            : // farther than the snapshot base block - and this function is also invoked
    5542                 :            : // from within ConnectTip, i.e. from within ActivateBestChain, so cs_main is
    5543                 :            : // held anyway.
    5544                 :            : //
    5545                 :            : // Eventually (TODO), we could somehow separate this function's runtime from
    5546                 :            : // maintenance of the active chain, but that will either require
    5547                 :            : //
    5548                 :            : //  (i) setting `m_disabled` immediately and ensuring all chainstate accesses go
    5549                 :            : //      through IsUsable() checks, or
    5550                 :            : //
    5551                 :            : //  (ii) giving each chainstate its own lock instead of using cs_main for everything.
    5552                 :          1 : SnapshotCompletionResult ChainstateManager::MaybeCompleteSnapshotValidation()
    5553                 :            : {
    5554                 :          1 :     AssertLockHeld(cs_main);
    5555   [ -  +  #  # ]:          1 :     if (m_ibd_chainstate.get() == &this->ActiveChainstate() ||
    5556         [ #  # ]:          0 :             !this->IsUsable(m_snapshot_chainstate.get()) ||
    5557         [ #  # ]:          0 :             !this->IsUsable(m_ibd_chainstate.get()) ||
    5558                 :          0 :             !m_ibd_chainstate->m_chain.Tip()) {
    5559                 :            :        // Nothing to do - this function only applies to the background
    5560                 :            :        // validation chainstate.
    5561                 :          1 :        return SnapshotCompletionResult::SKIPPED;
    5562                 :            :     }
    5563                 :          0 :     const int snapshot_tip_height = this->ActiveHeight();
    5564                 :          0 :     const int snapshot_base_height = *Assert(this->GetSnapshotBaseHeight());
    5565                 :          0 :     const CBlockIndex& index_new = *Assert(m_ibd_chainstate->m_chain.Tip());
    5566                 :            : 
    5567         [ #  # ]:          0 :     if (index_new.nHeight < snapshot_base_height) {
    5568                 :            :         // Background IBD not complete yet.
    5569                 :          0 :         return SnapshotCompletionResult::SKIPPED;
    5570                 :            :     }
    5571                 :            : 
    5572         [ #  # ]:          0 :     assert(SnapshotBlockhash());
    5573                 :          0 :     uint256 snapshot_blockhash = *Assert(SnapshotBlockhash());
    5574                 :            : 
    5575                 :          0 :     auto handle_invalid_snapshot = [&]() EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
    5576   [ #  #  #  # ]:          0 :         bilingual_str user_error = strprintf(_(
    5577                 :            :             "%s failed to validate the -assumeutxo snapshot state. "
    5578                 :            :             "This indicates a hardware problem, or a bug in the software, or a "
    5579                 :            :             "bad software modification that allowed an invalid snapshot to be "
    5580                 :            :             "loaded. As a result of this, the node will shut down and stop using any "
    5581                 :            :             "state that was built on the snapshot, resetting the chain height "
    5582                 :            :             "from %d to %d. On the next "
    5583                 :            :             "restart, the node will resume syncing from %d "
    5584                 :            :             "without using any snapshot data. "
    5585                 :            :             "Please report this incident to %s, including how you obtained the snapshot. "
    5586                 :            :             "The invalid snapshot chainstate will be left on disk in case it is "
    5587                 :            :             "helpful in diagnosing the issue that caused this error."),
    5588                 :          0 :             PACKAGE_NAME, snapshot_tip_height, snapshot_base_height, snapshot_base_height, PACKAGE_BUGREPORT
    5589                 :            :         );
    5590                 :            : 
    5591   [ #  #  #  #  :          0 :         LogPrintf("[snapshot] !!! %s\n", user_error.original);
                   #  # ]
    5592   [ #  #  #  #  :          0 :         LogPrintf("[snapshot] deleting snapshot, reverting to validated chain, and stopping node\n");
                   #  # ]
    5593                 :            : 
    5594                 :          0 :         m_active_chainstate = m_ibd_chainstate.get();
    5595                 :          0 :         m_snapshot_chainstate->m_disabled = true;
    5596         [ #  # ]:          0 :         assert(!this->IsUsable(m_snapshot_chainstate.get()));
    5597         [ #  # ]:          0 :         assert(this->IsUsable(m_ibd_chainstate.get()));
    5598                 :            : 
    5599         [ #  # ]:          0 :         auto rename_result = m_snapshot_chainstate->InvalidateCoinsDBOnDisk();
    5600         [ #  # ]:          0 :         if (!rename_result) {
    5601   [ #  #  #  #  :          0 :             user_error = strprintf(Untranslated("%s\n%s"), user_error, util::ErrorString(rename_result));
             #  #  #  # ]
    5602                 :          0 :         }
    5603                 :            : 
    5604         [ #  # ]:          0 :         GetNotifications().fatalError(user_error.original, user_error);
    5605                 :          0 :     };
    5606                 :            : 
    5607         [ #  # ]:          0 :     if (index_new.GetBlockHash() != snapshot_blockhash) {
    5608   [ #  #  #  #  :          0 :         LogPrintf("[snapshot] supposed base block %s does not match the "
          #  #  #  #  #  
                      # ]
    5609                 :            :           "snapshot base block %s (height %d). Snapshot is not valid.\n",
    5610                 :            :           index_new.ToString(), snapshot_blockhash.ToString(), snapshot_base_height);
    5611                 :          0 :         handle_invalid_snapshot();
    5612                 :          0 :         return SnapshotCompletionResult::BASE_BLOCKHASH_MISMATCH;
    5613                 :            :     }
    5614                 :            : 
    5615         [ #  # ]:          0 :     assert(index_new.nHeight == snapshot_base_height);
    5616                 :            : 
    5617                 :          0 :     int curr_height = m_ibd_chainstate->m_chain.Height();
    5618                 :            : 
    5619         [ #  # ]:          0 :     assert(snapshot_base_height == curr_height);
    5620         [ #  # ]:          0 :     assert(snapshot_base_height == index_new.nHeight);
    5621         [ #  # ]:          0 :     assert(this->IsUsable(m_snapshot_chainstate.get()));
    5622         [ #  # ]:          0 :     assert(this->GetAll().size() == 2);
    5623                 :            : 
    5624                 :          0 :     CCoinsViewDB& ibd_coins_db = m_ibd_chainstate->CoinsDB();
    5625                 :          0 :     m_ibd_chainstate->ForceFlushStateToDisk();
    5626                 :            : 
    5627                 :          0 :     const auto& maybe_au_data = m_options.chainparams.AssumeutxoForHeight(curr_height);
    5628         [ #  # ]:          0 :     if (!maybe_au_data) {
    5629   [ #  #  #  #  :          0 :         LogPrintf("[snapshot] assumeutxo data not found for height "
                   #  # ]
    5630                 :            :             "(%d) - refusing to validate snapshot\n", curr_height);
    5631                 :          0 :         handle_invalid_snapshot();
    5632                 :          0 :         return SnapshotCompletionResult::MISSING_CHAINPARAMS;
    5633                 :            :     }
    5634                 :            : 
    5635                 :          0 :     const AssumeutxoData& au_data = *maybe_au_data;
    5636                 :          0 :     std::optional<CCoinsStats> maybe_ibd_stats;
    5637   [ #  #  #  #  :          0 :     LogPrintf("[snapshot] computing UTXO stats for background chainstate to validate "
                   #  # ]
    5638                 :            :         "snapshot - this could take a few minutes\n");
    5639                 :            :     try {
    5640         [ #  # ]:          0 :         maybe_ibd_stats = ComputeUTXOStats(
    5641                 :            :             CoinStatsHashType::HASH_SERIALIZED,
    5642                 :          0 :             &ibd_coins_db,
    5643                 :          0 :             m_blockman,
    5644         [ #  # ]:          0 :             [&interrupt = m_interrupt] { SnapshotUTXOHashBreakpoint(interrupt); });
    5645         [ #  # ]:          0 :     } catch (StopHashingException const&) {
    5646                 :          0 :         return SnapshotCompletionResult::STATS_FAILED;
    5647                 :          0 :     }
    5648                 :            : 
    5649                 :            :     // XXX note that this function is slow and will hold cs_main for potentially minutes.
    5650         [ #  # ]:          0 :     if (!maybe_ibd_stats) {
    5651   [ #  #  #  #  :          0 :         LogPrintf("[snapshot] failed to generate stats for validation coins db\n");
                   #  # ]
    5652                 :            :         // While this isn't a problem with the snapshot per se, this condition
    5653                 :            :         // prevents us from validating the snapshot, so we should shut down and let the
    5654                 :            :         // user handle the issue manually.
    5655                 :          0 :         handle_invalid_snapshot();
    5656                 :          0 :         return SnapshotCompletionResult::STATS_FAILED;
    5657                 :            :     }
    5658                 :          0 :     const auto& ibd_stats = *maybe_ibd_stats;
    5659                 :            : 
    5660                 :            :     // Compare the background validation chainstate's UTXO set hash against the hard-coded
    5661                 :            :     // assumeutxo hash we expect.
    5662                 :            :     //
    5663                 :            :     // TODO: For belt-and-suspenders, we could cache the UTXO set
    5664                 :            :     // hash for the snapshot when it's loaded in its chainstate's leveldb. We could then
    5665                 :            :     // reference that here for an additional check.
    5666         [ #  # ]:          0 :     if (AssumeutxoHash{ibd_stats.hashSerialized} != au_data.hash_serialized) {
    5667   [ #  #  #  #  :          0 :         LogPrintf("[snapshot] hash mismatch: actual=%s, expected=%s\n",
          #  #  #  #  #  
                      # ]
    5668                 :            :             ibd_stats.hashSerialized.ToString(),
    5669                 :            :             au_data.hash_serialized.ToString());
    5670                 :          0 :         handle_invalid_snapshot();
    5671                 :          0 :         return SnapshotCompletionResult::HASH_MISMATCH;
    5672                 :            :     }
    5673                 :            : 
    5674   [ #  #  #  #  :          0 :     LogPrintf("[snapshot] snapshot beginning at %s has been fully validated\n",
             #  #  #  # ]
    5675                 :            :         snapshot_blockhash.ToString());
    5676                 :            : 
    5677                 :          0 :     m_ibd_chainstate->m_disabled = true;
    5678                 :          0 :     this->MaybeRebalanceCaches();
    5679                 :            : 
    5680                 :          0 :     return SnapshotCompletionResult::SUCCESS;
    5681                 :          1 : }
    5682                 :            : 
    5683                 :         13 : Chainstate& ChainstateManager::ActiveChainstate() const
    5684                 :            : {
    5685                 :         13 :     LOCK(::cs_main);
    5686         [ +  - ]:         13 :     assert(m_active_chainstate);
    5687                 :         13 :     return *m_active_chainstate;
    5688                 :         13 : }
    5689                 :            : 
    5690                 :          0 : bool ChainstateManager::IsSnapshotActive() const
    5691                 :            : {
    5692                 :          0 :     LOCK(::cs_main);
    5693         [ #  # ]:          0 :     return m_snapshot_chainstate && m_active_chainstate == m_snapshot_chainstate.get();
    5694                 :          0 : }
    5695                 :            : 
    5696                 :          1 : void ChainstateManager::MaybeRebalanceCaches()
    5697                 :            : {
    5698                 :          1 :     AssertLockHeld(::cs_main);
    5699                 :          1 :     bool ibd_usable = this->IsUsable(m_ibd_chainstate.get());
    5700                 :          1 :     bool snapshot_usable = this->IsUsable(m_snapshot_chainstate.get());
    5701   [ +  -  +  - ]:          1 :     assert(ibd_usable || snapshot_usable);
    5702                 :            : 
    5703   [ +  -  -  + ]:          1 :     if (ibd_usable && !snapshot_usable) {
    5704   [ +  -  +  -  :          1 :         LogPrintf("[snapshot] allocating all cache to the IBD chainstate\n");
                   +  - ]
    5705                 :            :         // Allocate everything to the IBD chainstate.
    5706                 :          1 :         m_ibd_chainstate->ResizeCoinsCaches(m_total_coinstip_cache, m_total_coinsdb_cache);
    5707                 :          1 :     }
    5708   [ #  #  #  # ]:          0 :     else if (snapshot_usable && !ibd_usable) {
    5709                 :            :         // If background validation has completed and snapshot is our active chain...
    5710   [ #  #  #  #  :          0 :         LogPrintf("[snapshot] allocating all cache to the snapshot chainstate\n");
                   #  # ]
    5711                 :            :         // Allocate everything to the snapshot chainstate.
    5712                 :          0 :         m_snapshot_chainstate->ResizeCoinsCaches(m_total_coinstip_cache, m_total_coinsdb_cache);
    5713                 :          0 :     }
    5714   [ #  #  #  # ]:          0 :     else if (ibd_usable && snapshot_usable) {
    5715                 :            :         // If both chainstates exist, determine who needs more cache based on IBD status.
    5716                 :            :         //
    5717                 :            :         // Note: shrink caches first so that we don't inadvertently overwhelm available memory.
    5718         [ #  # ]:          0 :         if (IsInitialBlockDownload()) {
    5719                 :          0 :             m_ibd_chainstate->ResizeCoinsCaches(
    5720                 :          0 :                 m_total_coinstip_cache * 0.05, m_total_coinsdb_cache * 0.05);
    5721                 :          0 :             m_snapshot_chainstate->ResizeCoinsCaches(
    5722                 :          0 :                 m_total_coinstip_cache * 0.95, m_total_coinsdb_cache * 0.95);
    5723                 :          0 :         } else {
    5724                 :          0 :             m_snapshot_chainstate->ResizeCoinsCaches(
    5725                 :          0 :                 m_total_coinstip_cache * 0.05, m_total_coinsdb_cache * 0.05);
    5726                 :          0 :             m_ibd_chainstate->ResizeCoinsCaches(
    5727                 :          0 :                 m_total_coinstip_cache * 0.95, m_total_coinsdb_cache * 0.95);
    5728                 :            :         }
    5729                 :          0 :     }
    5730                 :          1 : }
    5731                 :            : 
    5732                 :          0 : void ChainstateManager::ResetChainstates()
    5733                 :            : {
    5734                 :          0 :     m_ibd_chainstate.reset();
    5735                 :          0 :     m_snapshot_chainstate.reset();
    5736                 :          0 :     m_active_chainstate = nullptr;
    5737                 :          0 : }
    5738                 :            : 
    5739                 :            : /**
    5740                 :            :  * Apply default chain params to nullopt members.
    5741                 :            :  * This helps to avoid coding errors around the accidental use of the compare
    5742                 :            :  * operators that accept nullopt, thus ignoring the intended default value.
    5743                 :            :  */
    5744                 :          1 : static ChainstateManager::Options&& Flatten(ChainstateManager::Options&& opts)
    5745                 :            : {
    5746         [ +  - ]:          1 :     if (!opts.check_block_index.has_value()) opts.check_block_index = opts.chainparams.DefaultConsistencyChecks();
    5747         [ -  + ]:          1 :     if (!opts.minimum_chain_work.has_value()) opts.minimum_chain_work = UintToArith256(opts.chainparams.GetConsensus().nMinimumChainWork);
    5748         [ -  + ]:          1 :     if (!opts.assumed_valid_block.has_value()) opts.assumed_valid_block = opts.chainparams.GetConsensus().defaultAssumeValid;
    5749                 :          1 :     Assert(opts.adjusted_time_callback);
    5750                 :          1 :     return std::move(opts);
    5751                 :            : }
    5752                 :            : 
    5753                 :          4 : ChainstateManager::ChainstateManager(const util::SignalInterrupt& interrupt, Options options, node::BlockManager::Options blockman_options)
    5754                 :          1 :     : m_interrupt{interrupt},
    5755   [ +  -  +  - ]:          1 :       m_options{Flatten(std::move(options))},
    5756   [ +  -  +  - ]:          1 :       m_blockman{interrupt, std::move(blockman_options)} {}
    5757                 :            : 
    5758                 :          1 : ChainstateManager::~ChainstateManager()
    5759                 :            : {
    5760   [ +  -  +  - ]:          1 :     LOCK(::cs_main);
    5761                 :            : 
    5762         [ +  - ]:          1 :     m_versionbitscache.Clear();
    5763                 :          1 : }
    5764                 :            : 
    5765                 :          1 : bool ChainstateManager::DetectSnapshotChainstate(CTxMemPool* mempool)
    5766                 :            : {
    5767         [ +  - ]:          1 :     assert(!m_snapshot_chainstate);
    5768                 :          1 :     std::optional<fs::path> path = node::FindSnapshotChainstateDir(m_options.datadir);
    5769         [ -  + ]:          1 :     if (!path) {
    5770                 :          1 :         return false;
    5771                 :            :     }
    5772   [ #  #  #  #  :          0 :     std::optional<uint256> base_blockhash = node::ReadSnapshotBaseBlockhash(*path);
                   #  # ]
    5773         [ #  # ]:          0 :     if (!base_blockhash) {
    5774                 :          0 :         return false;
    5775                 :            :     }
    5776   [ #  #  #  #  :          0 :     LogPrintf("[snapshot] detected active snapshot chainstate (%s) - loading\n",
          #  #  #  #  #  
                      # ]
    5777                 :            :         fs::PathToString(*path));
    5778                 :            : 
    5779   [ #  #  #  # ]:          0 :     this->ActivateExistingSnapshot(*base_blockhash);
    5780                 :          0 :     return true;
    5781                 :          1 : }
    5782                 :            : 
    5783                 :          0 : Chainstate& ChainstateManager::ActivateExistingSnapshot(uint256 base_blockhash)
    5784                 :            : {
    5785         [ #  # ]:          0 :     assert(!m_snapshot_chainstate);
    5786                 :          0 :     m_snapshot_chainstate =
    5787                 :          0 :         std::make_unique<Chainstate>(nullptr, m_blockman, *this, base_blockhash);
    5788   [ #  #  #  #  :          0 :     LogPrintf("[snapshot] switching active chainstate to %s\n", m_snapshot_chainstate->ToString());
             #  #  #  # ]
    5789                 :            : 
    5790                 :            :     // Mempool is empty at this point because we're still in IBD.
    5791                 :          0 :     Assert(m_active_chainstate->m_mempool->size() == 0);
    5792                 :          0 :     Assert(!m_snapshot_chainstate->m_mempool);
    5793                 :          0 :     m_snapshot_chainstate->m_mempool = m_active_chainstate->m_mempool;
    5794                 :          0 :     m_active_chainstate->m_mempool = nullptr;
    5795                 :          0 :     m_active_chainstate = m_snapshot_chainstate.get();
    5796                 :          0 :     return *m_snapshot_chainstate;
    5797                 :          0 : }
    5798                 :            : 
    5799                 :          0 : bool IsBIP30Repeat(const CBlockIndex& block_index)
    5800                 :            : {
    5801   [ #  #  #  # ]:          0 :     return (block_index.nHeight==91842 && block_index.GetBlockHash() == uint256S("0x00000000000a4d0a398161ffc163c503763b1f4360639393e0e4c8e300e0caec")) ||
    5802         [ #  # ]:          0 :            (block_index.nHeight==91880 && block_index.GetBlockHash() == uint256S("0x00000000000743f190a18c5577a3c2d2a1f610ae9601ac046a38084ccb7cd721"));
    5803                 :            : }
    5804                 :            : 
    5805                 :          0 : bool IsBIP30Unspendable(const CBlockIndex& block_index)
    5806                 :            : {
    5807   [ #  #  #  # ]:          0 :     return (block_index.nHeight==91722 && block_index.GetBlockHash() == uint256S("0x00000000000271a2dc26e7667f8419f2e15416dc6955e5a6c6cdf3f2574dd08e")) ||
    5808         [ #  # ]:          0 :            (block_index.nHeight==91812 && block_index.GetBlockHash() == uint256S("0x00000000000af0aed4792b1acee3d966af36cf5def14935db8de83d6f9306f2f"));
    5809                 :            : }
    5810                 :            : 
    5811                 :          0 : static fs::path GetSnapshotCoinsDBPath(Chainstate& cs) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
    5812                 :            : {
    5813                 :          0 :     AssertLockHeld(::cs_main);
    5814                 :            :     // Should never be called on a non-snapshot chainstate.
    5815         [ #  # ]:          0 :     assert(cs.m_from_snapshot_blockhash);
    5816                 :          0 :     auto storage_path_maybe = cs.CoinsDB().StoragePath();
    5817                 :            :     // Should never be called with a non-existent storage path.
    5818         [ #  # ]:          0 :     assert(storage_path_maybe);
    5819         [ #  # ]:          0 :     return *storage_path_maybe;
    5820                 :          0 : }
    5821                 :            : 
    5822                 :          0 : util::Result<void> Chainstate::InvalidateCoinsDBOnDisk()
    5823                 :            : {
    5824                 :          0 :     fs::path snapshot_datadir = GetSnapshotCoinsDBPath(*this);
    5825                 :            : 
    5826                 :            :     // Coins views no longer usable.
    5827                 :          0 :     m_coins_views.reset();
    5828                 :            : 
    5829   [ #  #  #  # ]:          0 :     auto invalid_path = snapshot_datadir + "_INVALID";
    5830         [ #  # ]:          0 :     std::string dbpath = fs::PathToString(snapshot_datadir);
    5831         [ #  # ]:          0 :     std::string target = fs::PathToString(invalid_path);
    5832   [ #  #  #  #  :          0 :     LogPrintf("[snapshot] renaming snapshot datadir %s to %s\n", dbpath, target);
                   #  # ]
    5833                 :            : 
    5834                 :            :     // The invalid snapshot datadir is simply moved and not deleted because we may
    5835                 :            :     // want to do forensics later during issue investigation. The user is instructed
    5836                 :            :     // accordingly in MaybeCompleteSnapshotValidation().
    5837                 :            :     try {
    5838         [ #  # ]:          0 :         fs::rename(snapshot_datadir, invalid_path);
    5839         [ #  # ]:          0 :     } catch (const fs::filesystem_error& e) {
    5840         [ #  # ]:          0 :         auto src_str = fs::PathToString(snapshot_datadir);
    5841         [ #  # ]:          0 :         auto dest_str = fs::PathToString(invalid_path);
    5842                 :            : 
    5843   [ #  #  #  #  :          0 :         LogPrintf("%s: error renaming file '%s' -> '%s': %s\n",
                   #  # ]
    5844                 :            :                 __func__, src_str, dest_str, e.what());
    5845   [ #  #  #  #  :          0 :         return util::Error{strprintf(_(
                   #  # ]
    5846                 :            :             "Rename of '%s' -> '%s' failed. "
    5847                 :            :             "You should resolve this by manually moving or deleting the invalid "
    5848                 :            :             "snapshot directory %s, otherwise you will encounter the same error again "
    5849                 :            :             "on the next startup."),
    5850                 :            :             src_str, dest_str, src_str)};
    5851   [ #  #  #  # ]:          0 :     }
    5852         [ #  # ]:          0 :     return {};
    5853                 :          0 : }
    5854                 :            : 
    5855                 :          0 : bool ChainstateManager::DeleteSnapshotChainstate()
    5856                 :            : {
    5857                 :          0 :     AssertLockHeld(::cs_main);
    5858                 :          0 :     Assert(m_snapshot_chainstate);
    5859                 :          0 :     Assert(m_ibd_chainstate);
    5860                 :            : 
    5861                 :          0 :     fs::path snapshot_datadir = GetSnapshotCoinsDBPath(*m_snapshot_chainstate);
    5862   [ #  #  #  #  :          0 :     if (!DeleteCoinsDBFromDisk(snapshot_datadir, /*is_snapshot=*/ true)) {
                   #  # ]
    5863   [ #  #  #  #  :          0 :         LogPrintf("Deletion of %s failed. Please remove it manually to continue reindexing.\n",
             #  #  #  # ]
    5864                 :            :                   fs::PathToString(snapshot_datadir));
    5865                 :          0 :         return false;
    5866                 :            :     }
    5867                 :          0 :     m_active_chainstate = m_ibd_chainstate.get();
    5868                 :          0 :     m_snapshot_chainstate.reset();
    5869                 :          0 :     return true;
    5870                 :          0 : }
    5871                 :            : 
    5872                 :          1 : ChainstateRole Chainstate::GetRole() const
    5873                 :            : {
    5874         [ +  - ]:          1 :     if (m_chainman.GetAll().size() <= 1) {
    5875                 :          1 :         return ChainstateRole::NORMAL;
    5876                 :            :     }
    5877                 :          0 :     return (this != &m_chainman.ActiveChainstate()) ?
    5878                 :            :                ChainstateRole::BACKGROUND :
    5879                 :            :                ChainstateRole::ASSUMEDVALID;
    5880                 :          1 : }
    5881                 :            : 
    5882                 :          0 : const CBlockIndex* ChainstateManager::GetSnapshotBaseBlock() const
    5883                 :            : {
    5884         [ #  # ]:          0 :     return m_active_chainstate ? m_active_chainstate->SnapshotBase() : nullptr;
    5885                 :            : }
    5886                 :            : 
    5887                 :          0 : std::optional<int> ChainstateManager::GetSnapshotBaseHeight() const
    5888                 :            : {
    5889                 :          0 :     const CBlockIndex* base = this->GetSnapshotBaseBlock();
    5890         [ #  # ]:          0 :     return base ? std::make_optional(base->nHeight) : std::nullopt;
    5891                 :            : }
    5892                 :            : 
    5893                 :          0 : bool ChainstateManager::ValidatedSnapshotCleanup()
    5894                 :            : {
    5895                 :          0 :     AssertLockHeld(::cs_main);
    5896                 :          0 :     auto get_storage_path = [](auto& chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) -> std::optional<fs::path> {
    5897   [ #  #  #  # ]:          0 :         if (!(chainstate && chainstate->HasCoinsViews())) {
    5898                 :          0 :             return {};
    5899                 :            :         }
    5900                 :          0 :         return chainstate->CoinsDB().StoragePath();
    5901                 :          0 :     };
    5902                 :          0 :     std::optional<fs::path> ibd_chainstate_path_maybe = get_storage_path(m_ibd_chainstate);
    5903         [ #  # ]:          0 :     std::optional<fs::path> snapshot_chainstate_path_maybe = get_storage_path(m_snapshot_chainstate);
    5904                 :            : 
    5905   [ #  #  #  # ]:          0 :     if (!this->IsSnapshotValidated()) {
    5906                 :            :         // No need to clean up.
    5907                 :          0 :         return false;
    5908                 :            :     }
    5909                 :            :     // If either path doesn't exist, that means at least one of the chainstates
    5910                 :            :     // is in-memory, in which case we can't do on-disk cleanup. You'd better be
    5911                 :            :     // in a unittest!
    5912   [ #  #  #  # ]:          0 :     if (!ibd_chainstate_path_maybe || !snapshot_chainstate_path_maybe) {
    5913   [ #  #  #  #  :          0 :         LogPrintf("[snapshot] snapshot chainstate cleanup cannot happen with "
                   #  # ]
    5914                 :            :                   "in-memory chainstates. You are testing, right?\n");
    5915                 :          0 :         return false;
    5916                 :            :     }
    5917                 :            : 
    5918         [ #  # ]:          0 :     const auto& snapshot_chainstate_path = *snapshot_chainstate_path_maybe;
    5919         [ #  # ]:          0 :     const auto& ibd_chainstate_path = *ibd_chainstate_path_maybe;
    5920                 :            : 
    5921                 :            :     // Since we're going to be moving around the underlying leveldb filesystem content
    5922                 :            :     // for each chainstate, make sure that the chainstates (and their constituent
    5923                 :            :     // CoinsViews members) have been destructed first.
    5924                 :            :     //
    5925                 :            :     // The caller of this method will be responsible for reinitializing chainstates
    5926                 :            :     // if they want to continue operation.
    5927                 :          0 :     this->ResetChainstates();
    5928                 :            : 
    5929                 :            :     // No chainstates should be considered usable.
    5930   [ #  #  #  # ]:          0 :     assert(this->GetAll().size() == 0);
    5931                 :            : 
    5932   [ #  #  #  #  :          0 :     LogPrintf("[snapshot] deleting background chainstate directory (now unnecessary) (%s)\n",
             #  #  #  # ]
    5933                 :            :               fs::PathToString(ibd_chainstate_path));
    5934                 :            : 
    5935   [ #  #  #  # ]:          0 :     fs::path tmp_old{ibd_chainstate_path + "_todelete"};
    5936                 :            : 
    5937                 :          0 :     auto rename_failed_abort = [this](
    5938                 :            :                                    fs::path p_old,
    5939                 :            :                                    fs::path p_new,
    5940                 :            :                                    const fs::filesystem_error& err) {
    5941   [ #  #  #  #  :          0 :         LogPrintf("%s: error renaming file (%s): %s\n",
             #  #  #  # ]
    5942                 :            :                 __func__, fs::PathToString(p_old), err.what());
    5943   [ #  #  #  # ]:          0 :         GetNotifications().fatalError(strprintf(
    5944                 :            :             "Rename of '%s' -> '%s' failed. "
    5945                 :            :             "Cannot clean up the background chainstate leveldb directory.",
    5946         [ #  # ]:          0 :             fs::PathToString(p_old), fs::PathToString(p_new)));
    5947                 :          0 :     };
    5948                 :            : 
    5949                 :            :     try {
    5950         [ #  # ]:          0 :         fs::rename(ibd_chainstate_path, tmp_old);
    5951         [ #  # ]:          0 :     } catch (const fs::filesystem_error& e) {
    5952   [ #  #  #  #  :          0 :         rename_failed_abort(ibd_chainstate_path, tmp_old, e);
                   #  # ]
    5953                 :          0 :         throw;
    5954         [ #  # ]:          0 :     }
    5955                 :            : 
    5956   [ #  #  #  #  :          0 :     LogPrintf("[snapshot] moving snapshot chainstate (%s) to "
          #  #  #  #  #  
                      # ]
    5957                 :            :               "default chainstate directory (%s)\n",
    5958                 :            :               fs::PathToString(snapshot_chainstate_path), fs::PathToString(ibd_chainstate_path));
    5959                 :            : 
    5960                 :            :     try {
    5961         [ #  # ]:          0 :         fs::rename(snapshot_chainstate_path, ibd_chainstate_path);
    5962         [ #  # ]:          0 :     } catch (const fs::filesystem_error& e) {
    5963   [ #  #  #  #  :          0 :         rename_failed_abort(snapshot_chainstate_path, ibd_chainstate_path, e);
                   #  # ]
    5964                 :          0 :         throw;
    5965         [ #  # ]:          0 :     }
    5966                 :            : 
    5967   [ #  #  #  #  :          0 :     if (!DeleteCoinsDBFromDisk(tmp_old, /*is_snapshot=*/false)) {
                   #  # ]
    5968                 :            :         // No need to FatalError because once the unneeded bg chainstate data is
    5969                 :            :         // moved, it will not interfere with subsequent initialization.
    5970   [ #  #  #  #  :          0 :         LogPrintf("Deletion of %s failed. Please remove it manually, as the "
             #  #  #  # ]
    5971                 :            :                   "directory is now unnecessary.\n",
    5972                 :            :                   fs::PathToString(tmp_old));
    5973                 :          0 :     } else {
    5974   [ #  #  #  #  :          0 :         LogPrintf("[snapshot] deleted background chainstate directory (%s)\n",
             #  #  #  # ]
    5975                 :            :                   fs::PathToString(ibd_chainstate_path));
    5976                 :            :     }
    5977                 :          0 :     return true;
    5978                 :          0 : }
    5979                 :            : 
    5980                 :          0 : Chainstate& ChainstateManager::GetChainstateForIndexing()
    5981                 :            : {
    5982                 :            :     // We can't always return `m_ibd_chainstate` because after background validation
    5983                 :            :     // has completed, `m_snapshot_chainstate == m_active_chainstate`, but it can be
    5984                 :            :     // indexed.
    5985   [ #  #  #  # ]:          0 :     return (this->GetAll().size() > 1) ? *m_ibd_chainstate : *m_active_chainstate;
    5986                 :          0 : }
    5987                 :            : 
    5988                 :          0 : std::pair<int, int> ChainstateManager::GetPruneRange(const Chainstate& chainstate, int last_height_can_prune)
    5989                 :            : {
    5990         [ #  # ]:          0 :     if (chainstate.m_chain.Height() <= 0) {
    5991                 :          0 :         return {0, 0};
    5992                 :            :     }
    5993                 :          0 :     int prune_start{0};
    5994                 :            : 
    5995   [ #  #  #  # ]:          0 :     if (this->GetAll().size() > 1 && m_snapshot_chainstate.get() == &chainstate) {
    5996                 :            :         // Leave the blocks in the background IBD chain alone if we're pruning
    5997                 :            :         // the snapshot chain.
    5998                 :          0 :         prune_start = *Assert(GetSnapshotBaseHeight()) + 1;
    5999                 :          0 :     }
    6000                 :            : 
    6001                 :          0 :     int max_prune = std::max<int>(
    6002                 :          0 :         0, chainstate.m_chain.Height() - static_cast<int>(MIN_BLOCKS_TO_KEEP));
    6003                 :            : 
    6004                 :            :     // last block to prune is the lesser of (caller-specified height, MIN_BLOCKS_TO_KEEP from the tip)
    6005                 :            :     //
    6006                 :            :     // While you might be tempted to prune the background chainstate more
    6007                 :            :     // aggressively (i.e. fewer MIN_BLOCKS_TO_KEEP), this won't work with index
    6008                 :            :     // building - specifically blockfilterindex requires undo data, and if
    6009                 :            :     // we don't maintain this trailing window, we hit indexing failures.
    6010                 :          0 :     int prune_end = std::min(last_height_can_prune, max_prune);
    6011                 :            : 
    6012                 :          0 :     return {prune_start, prune_end};
    6013                 :          0 : }

Generated by: LCOV version 1.14