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

Generated by: LCOV version 1.14