LCOV - code coverage report
Current view: top level - src - validation.cpp (source / functions) Hit Total Coverage
Test: fuzz_coverage.info Lines: 11 3063 0.4 %
Date: 2024-01-03 14:57:27 Functions: 0 187 0.0 %
Branches: 7 6034 0.1 %

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

Generated by: LCOV version 1.14