/workdir/bitcoin/src/validation.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | // Copyright (c) 2009-2010 Satoshi Nakamoto |
2 | | // Copyright (c) 2009-present 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 <config/bitcoin-config.h> // IWYU pragma: keep |
7 | | |
8 | | #include <validation.h> |
9 | | |
10 | | #include <arith_uint256.h> |
11 | | #include <chain.h> |
12 | | #include <checkqueue.h> |
13 | | #include <clientversion.h> |
14 | | #include <consensus/amount.h> |
15 | | #include <consensus/consensus.h> |
16 | | #include <consensus/merkle.h> |
17 | | #include <consensus/tx_check.h> |
18 | | #include <consensus/tx_verify.h> |
19 | | #include <consensus/validation.h> |
20 | | #include <cuckoocache.h> |
21 | | #include <flatfile.h> |
22 | | #include <hash.h> |
23 | | #include <kernel/chain.h> |
24 | | #include <kernel/chainparams.h> |
25 | | #include <kernel/coinstats.h> |
26 | | #include <kernel/disconnected_transactions.h> |
27 | | #include <kernel/mempool_entry.h> |
28 | | #include <kernel/messagestartchars.h> |
29 | | #include <kernel/notifications_interface.h> |
30 | | #include <kernel/warning.h> |
31 | | #include <logging.h> |
32 | | #include <logging/timer.h> |
33 | | #include <node/blockstorage.h> |
34 | | #include <node/utxo_snapshot.h> |
35 | | #include <policy/policy.h> |
36 | | #include <policy/rbf.h> |
37 | | #include <policy/settings.h> |
38 | | #include <policy/truc_policy.h> |
39 | | #include <pow.h> |
40 | | #include <primitives/block.h> |
41 | | #include <primitives/transaction.h> |
42 | | #include <random.h> |
43 | | #include <script/script.h> |
44 | | #include <script/sigcache.h> |
45 | | #include <signet.h> |
46 | | #include <tinyformat.h> |
47 | | #include <txdb.h> |
48 | | #include <txmempool.h> |
49 | | #include <uint256.h> |
50 | | #include <undo.h> |
51 | | #include <util/check.h> |
52 | | #include <util/fs.h> |
53 | | #include <util/fs_helpers.h> |
54 | | #include <util/hasher.h> |
55 | | #include <util/moneystr.h> |
56 | | #include <util/rbf.h> |
57 | | #include <util/result.h> |
58 | | #include <util/signalinterrupt.h> |
59 | | #include <util/strencodings.h> |
60 | | #include <util/string.h> |
61 | | #include <util/time.h> |
62 | | #include <util/trace.h> |
63 | | #include <util/translation.h> |
64 | | #include <validationinterface.h> |
65 | | |
66 | | #include <algorithm> |
67 | | #include <cassert> |
68 | | #include <chrono> |
69 | | #include <deque> |
70 | | #include <numeric> |
71 | | #include <optional> |
72 | | #include <ranges> |
73 | | #include <string> |
74 | | #include <tuple> |
75 | | #include <utility> |
76 | | |
77 | | using kernel::CCoinsStats; |
78 | | using kernel::CoinStatsHashType; |
79 | | using kernel::ComputeUTXOStats; |
80 | | using kernel::Notifications; |
81 | | |
82 | | using fsbridge::FopenFn; |
83 | | using node::BlockManager; |
84 | | using node::BlockMap; |
85 | | using node::CBlockIndexHeightOnlyComparator; |
86 | | using node::CBlockIndexWorkComparator; |
87 | | using node::SnapshotMetadata; |
88 | | |
89 | | /** Time to wait between writing blocks/block index to disk. */ |
90 | | static constexpr std::chrono::hours DATABASE_WRITE_INTERVAL{1}; |
91 | | /** Time to wait between flushing chainstate to disk. */ |
92 | | static constexpr std::chrono::hours DATABASE_FLUSH_INTERVAL{24}; |
93 | | /** Maximum age of our tip for us to be considered current for fee estimation */ |
94 | | static constexpr std::chrono::hours MAX_FEE_ESTIMATION_TIP_AGE{3}; |
95 | | const std::vector<std::string> CHECKLEVEL_DOC { |
96 | | "level 0 reads the blocks from disk", |
97 | | "level 1 verifies block validity", |
98 | | "level 2 verifies undo data", |
99 | | "level 3 checks disconnection of tip blocks", |
100 | | "level 4 tries to reconnect the blocks", |
101 | | "each level includes the checks of the previous levels", |
102 | | }; |
103 | | /** The number of blocks to keep below the deepest prune lock. |
104 | | * There is nothing special about this number. It is higher than what we |
105 | | * expect to see in regular mainnet reorgs, but not so high that it would |
106 | | * noticeably interfere with the pruning mechanism. |
107 | | * */ |
108 | | static constexpr int PRUNE_LOCK_BUFFER{10}; |
109 | | |
110 | | /** |
111 | | * Maximum number of seconds that the timestamp of the first |
112 | | * block of a difficulty adjustment period is allowed to |
113 | | * be earlier than the last block of the previous period (BIP94). |
114 | | */ |
115 | | static constexpr int64_t MAX_TIMEWARP{MAX_FUTURE_BLOCK_TIME}; |
116 | | |
117 | | /** |
118 | | * If the timestamp of the last block in a difficulty period is set |
119 | | * MAX_FUTURE_BLOCK_TIME seconds in the future, an honest miner should |
120 | | * be able to mine the first block using the current time. This is not |
121 | | * a consensus rule, but changing MAX_TIMEWARP should be done with caution. |
122 | | */ |
123 | | static_assert(MAX_FUTURE_BLOCK_TIME <= MAX_TIMEWARP); |
124 | | |
125 | | GlobalMutex g_best_block_mutex; |
126 | | std::condition_variable g_best_block_cv; |
127 | | uint256 g_best_block; |
128 | | |
129 | | const CBlockIndex* Chainstate::FindForkInGlobalIndex(const CBlockLocator& locator) const |
130 | 0 | { |
131 | 0 | AssertLockHeld(cs_main); |
132 | | |
133 | | // Find the latest block common to locator and chain - we expect that |
134 | | // locator.vHave is sorted descending by height. |
135 | 0 | for (const uint256& hash : locator.vHave) { Branch (135:30): [True: 0, False: 0]
|
136 | 0 | const CBlockIndex* pindex{m_blockman.LookupBlockIndex(hash)}; |
137 | 0 | if (pindex) { Branch (137:13): [True: 0, False: 0]
|
138 | 0 | if (m_chain.Contains(pindex)) { Branch (138:17): [True: 0, False: 0]
|
139 | 0 | return pindex; |
140 | 0 | } |
141 | 0 | if (pindex->GetAncestor(m_chain.Height()) == m_chain.Tip()) { Branch (141:17): [True: 0, False: 0]
|
142 | 0 | return m_chain.Tip(); |
143 | 0 | } |
144 | 0 | } |
145 | 0 | } |
146 | 0 | return m_chain.Genesis(); |
147 | 0 | } |
148 | | |
149 | | bool CheckInputScripts(const CTransaction& tx, TxValidationState& state, |
150 | | const CCoinsViewCache& inputs, unsigned int flags, bool cacheSigStore, |
151 | | bool cacheFullScriptStore, PrecomputedTransactionData& txdata, |
152 | | ValidationCache& validation_cache, |
153 | | std::vector<CScriptCheck>* pvChecks = nullptr) |
154 | | EXCLUSIVE_LOCKS_REQUIRED(cs_main); |
155 | | |
156 | | bool CheckFinalTxAtTip(const CBlockIndex& active_chain_tip, const CTransaction& tx) |
157 | 0 | { |
158 | 0 | AssertLockHeld(cs_main); |
159 | | |
160 | | // CheckFinalTxAtTip() uses active_chain_tip.Height()+1 to evaluate |
161 | | // nLockTime because when IsFinalTx() is called within |
162 | | // AcceptBlock(), the height of the block *being* |
163 | | // evaluated is what is used. Thus if we want to know if a |
164 | | // transaction can be part of the *next* block, we need to call |
165 | | // IsFinalTx() with one more than active_chain_tip.Height(). |
166 | 0 | const int nBlockHeight = active_chain_tip.nHeight + 1; |
167 | | |
168 | | // BIP113 requires that time-locked transactions have nLockTime set to |
169 | | // less than the median time of the previous block they're contained in. |
170 | | // When the next block is created its previous block will be the current |
171 | | // chain tip, so we use that to calculate the median time passed to |
172 | | // IsFinalTx(). |
173 | 0 | const int64_t nBlockTime{active_chain_tip.GetMedianTimePast()}; |
174 | |
|
175 | 0 | return IsFinalTx(tx, nBlockHeight, nBlockTime); |
176 | 0 | } |
177 | | |
178 | | namespace { |
179 | | /** |
180 | | * A helper which calculates heights of inputs of a given transaction. |
181 | | * |
182 | | * @param[in] tip The current chain tip. If an input belongs to a mempool |
183 | | * transaction, we assume it will be confirmed in the next block. |
184 | | * @param[in] coins Any CCoinsView that provides access to the relevant coins. |
185 | | * @param[in] tx The transaction being evaluated. |
186 | | * |
187 | | * @returns A vector of input heights or nullopt, in case of an error. |
188 | | */ |
189 | | std::optional<std::vector<int>> CalculatePrevHeights( |
190 | | const CBlockIndex& tip, |
191 | | const CCoinsView& coins, |
192 | | const CTransaction& tx) |
193 | 0 | { |
194 | 0 | std::vector<int> prev_heights; |
195 | 0 | prev_heights.resize(tx.vin.size()); |
196 | 0 | for (size_t i = 0; i < tx.vin.size(); ++i) { Branch (196:24): [True: 0, False: 0]
|
197 | 0 | const CTxIn& txin = tx.vin[i]; |
198 | 0 | Coin coin; |
199 | 0 | if (!coins.GetCoin(txin.prevout, coin)) { Branch (199:13): [True: 0, False: 0]
|
200 | 0 | LogPrintf("ERROR: %s: Missing input %d in transaction \'%s\'\n", __func__, i, tx.GetHash().GetHex()); |
201 | 0 | return std::nullopt; |
202 | 0 | } |
203 | 0 | if (coin.nHeight == MEMPOOL_HEIGHT) { Branch (203:13): [True: 0, False: 0]
|
204 | | // Assume all mempool transaction confirm in the next block. |
205 | 0 | prev_heights[i] = tip.nHeight + 1; |
206 | 0 | } else { |
207 | 0 | prev_heights[i] = coin.nHeight; |
208 | 0 | } |
209 | 0 | } |
210 | 0 | return prev_heights; |
211 | 0 | } |
212 | | } // namespace |
213 | | |
214 | | std::optional<LockPoints> CalculateLockPointsAtTip( |
215 | | CBlockIndex* tip, |
216 | | const CCoinsView& coins_view, |
217 | | const CTransaction& tx) |
218 | 0 | { |
219 | 0 | assert(tip); |
220 | | |
221 | 0 | auto prev_heights{CalculatePrevHeights(*tip, coins_view, tx)}; |
222 | 0 | if (!prev_heights.has_value()) return std::nullopt; Branch (222:9): [True: 0, False: 0]
|
223 | | |
224 | 0 | CBlockIndex next_tip; |
225 | 0 | next_tip.pprev = tip; |
226 | | // When SequenceLocks() is called within ConnectBlock(), the height |
227 | | // of the block *being* evaluated is what is used. |
228 | | // Thus if we want to know if a transaction can be part of the |
229 | | // *next* block, we need to use one more than active_chainstate.m_chain.Height() |
230 | 0 | next_tip.nHeight = tip->nHeight + 1; |
231 | 0 | const auto [min_height, min_time] = CalculateSequenceLocks(tx, STANDARD_LOCKTIME_VERIFY_FLAGS, prev_heights.value(), next_tip); |
232 | | |
233 | | // Also store the hash of the block with the highest height of |
234 | | // all the blocks which have sequence locked prevouts. |
235 | | // This hash needs to still be on the chain |
236 | | // for these LockPoint calculations to be valid |
237 | | // Note: It is impossible to correctly calculate a maxInputBlock |
238 | | // if any of the sequence locked inputs depend on unconfirmed txs, |
239 | | // except in the special case where the relative lock time/height |
240 | | // is 0, which is equivalent to no sequence lock. Since we assume |
241 | | // input height of tip+1 for mempool txs and test the resulting |
242 | | // min_height and min_time from CalculateSequenceLocks against tip+1. |
243 | 0 | int max_input_height{0}; |
244 | 0 | for (const int height : prev_heights.value()) { Branch (244:27): [True: 0, False: 0]
|
245 | | // Can ignore mempool inputs since we'll fail if they had non-zero locks |
246 | 0 | if (height != next_tip.nHeight) { Branch (246:13): [True: 0, False: 0]
|
247 | 0 | max_input_height = std::max(max_input_height, height); |
248 | 0 | } |
249 | 0 | } |
250 | | |
251 | | // tip->GetAncestor(max_input_height) should never return a nullptr |
252 | | // because max_input_height is always less than the tip height. |
253 | | // It would, however, be a bad bug to continue execution, since a |
254 | | // LockPoints object with the maxInputBlock member set to nullptr |
255 | | // signifies no relative lock time. |
256 | 0 | return LockPoints{min_height, min_time, Assert(tip->GetAncestor(max_input_height))}; |
257 | 0 | } |
258 | | |
259 | | bool CheckSequenceLocksAtTip(CBlockIndex* tip, |
260 | | const LockPoints& lock_points) |
261 | 0 | { |
262 | 0 | assert(tip != nullptr); |
263 | | |
264 | 0 | CBlockIndex index; |
265 | 0 | index.pprev = tip; |
266 | | // CheckSequenceLocksAtTip() uses active_chainstate.m_chain.Height()+1 to evaluate |
267 | | // height based locks because when SequenceLocks() is called within |
268 | | // ConnectBlock(), the height of the block *being* |
269 | | // evaluated is what is used. |
270 | | // Thus if we want to know if a transaction can be part of the |
271 | | // *next* block, we need to use one more than active_chainstate.m_chain.Height() |
272 | 0 | index.nHeight = tip->nHeight + 1; |
273 | |
|
274 | 0 | return EvaluateSequenceLocks(index, {lock_points.height, lock_points.time}); |
275 | 0 | } |
276 | | |
277 | | // Returns the script flags which should be checked for a given block |
278 | | static unsigned int GetBlockScriptFlags(const CBlockIndex& block_index, const ChainstateManager& chainman); |
279 | | |
280 | | static void LimitMempoolSize(CTxMemPool& pool, CCoinsViewCache& coins_cache) |
281 | | EXCLUSIVE_LOCKS_REQUIRED(::cs_main, pool.cs) |
282 | 0 | { |
283 | 0 | AssertLockHeld(::cs_main); |
284 | 0 | AssertLockHeld(pool.cs); |
285 | 0 | int expired = pool.Expire(GetTime<std::chrono::seconds>() - pool.m_opts.expiry); |
286 | 0 | if (expired != 0) { Branch (286:9): [True: 0, False: 0]
|
287 | 0 | LogPrint(BCLog::MEMPOOL, "Expired %i transactions from the memory pool\n", expired); |
288 | 0 | } |
289 | |
|
290 | 0 | std::vector<COutPoint> vNoSpendsRemaining; |
291 | 0 | pool.TrimToSize(pool.m_opts.max_size_bytes, &vNoSpendsRemaining); |
292 | 0 | for (const COutPoint& removed : vNoSpendsRemaining) Branch (292:35): [True: 0, False: 0]
|
293 | 0 | coins_cache.Uncache(removed); |
294 | 0 | } |
295 | | |
296 | | static bool IsCurrentForFeeEstimation(Chainstate& active_chainstate) EXCLUSIVE_LOCKS_REQUIRED(cs_main) |
297 | 0 | { |
298 | 0 | AssertLockHeld(cs_main); |
299 | 0 | if (active_chainstate.m_chainman.IsInitialBlockDownload()) { Branch (299:9): [True: 0, False: 0]
|
300 | 0 | return false; |
301 | 0 | } |
302 | 0 | if (active_chainstate.m_chain.Tip()->GetBlockTime() < count_seconds(GetTime<std::chrono::seconds>() - MAX_FEE_ESTIMATION_TIP_AGE)) Branch (302:9): [True: 0, False: 0]
|
303 | 0 | return false; |
304 | 0 | if (active_chainstate.m_chain.Height() < active_chainstate.m_chainman.m_best_header->nHeight - 1) { Branch (304:9): [True: 0, False: 0]
|
305 | 0 | return false; |
306 | 0 | } |
307 | 0 | return true; |
308 | 0 | } |
309 | | |
310 | | void Chainstate::MaybeUpdateMempoolForReorg( |
311 | | DisconnectedBlockTransactions& disconnectpool, |
312 | | bool fAddToMempool) |
313 | 0 | { |
314 | 0 | if (!m_mempool) return; Branch (314:9): [True: 0, False: 0]
|
315 | | |
316 | 0 | AssertLockHeld(cs_main); |
317 | 0 | AssertLockHeld(m_mempool->cs); |
318 | 0 | std::vector<uint256> vHashUpdate; |
319 | 0 | { |
320 | | // disconnectpool is ordered so that the front is the most recently-confirmed |
321 | | // transaction (the last tx of the block at the tip) in the disconnected chain. |
322 | | // Iterate disconnectpool in reverse, so that we add transactions |
323 | | // back to the mempool starting with the earliest transaction that had |
324 | | // been previously seen in a block. |
325 | 0 | const auto queuedTx = disconnectpool.take(); |
326 | 0 | auto it = queuedTx.rbegin(); |
327 | 0 | while (it != queuedTx.rend()) { Branch (327:16): [True: 0, False: 0]
|
328 | | // ignore validation errors in resurrected transactions |
329 | 0 | if (!fAddToMempool || (*it)->IsCoinBase() || Branch (329:17): [True: 0, False: 0]
Branch (329:17): [True: 0, False: 0]
Branch (329:35): [True: 0, False: 0]
|
330 | 0 | AcceptToMemoryPool(*this, *it, GetTime(), Branch (330:17): [True: 0, False: 0]
|
331 | 0 | /*bypass_limits=*/true, /*test_accept=*/false).m_result_type != |
332 | 0 | MempoolAcceptResult::ResultType::VALID) { |
333 | | // If the transaction doesn't make it in to the mempool, remove any |
334 | | // transactions that depend on it (which would now be orphans). |
335 | 0 | m_mempool->removeRecursive(**it, MemPoolRemovalReason::REORG); |
336 | 0 | } else if (m_mempool->exists(GenTxid::Txid((*it)->GetHash()))) { Branch (336:24): [True: 0, False: 0]
|
337 | 0 | vHashUpdate.push_back((*it)->GetHash()); |
338 | 0 | } |
339 | 0 | ++it; |
340 | 0 | } |
341 | 0 | } |
342 | | |
343 | | // AcceptToMemoryPool/addUnchecked all assume that new mempool entries have |
344 | | // no in-mempool children, which is generally not true when adding |
345 | | // previously-confirmed transactions back to the mempool. |
346 | | // UpdateTransactionsFromBlock finds descendants of any transactions in |
347 | | // the disconnectpool that were added back and cleans up the mempool state. |
348 | 0 | m_mempool->UpdateTransactionsFromBlock(vHashUpdate); |
349 | | |
350 | | // Predicate to use for filtering transactions in removeForReorg. |
351 | | // Checks whether the transaction is still final and, if it spends a coinbase output, mature. |
352 | | // Also updates valid entries' cached LockPoints if needed. |
353 | | // If false, the tx is still valid and its lockpoints are updated. |
354 | | // If true, the tx would be invalid in the next block; remove this entry and all of its descendants. |
355 | | // Note that TRUC rules are not applied here, so reorgs may cause violations of TRUC inheritance or |
356 | | // topology restrictions. |
357 | 0 | const auto filter_final_and_mature = [&](CTxMemPool::txiter it) |
358 | 0 | EXCLUSIVE_LOCKS_REQUIRED(m_mempool->cs, ::cs_main) { |
359 | 0 | AssertLockHeld(m_mempool->cs); |
360 | 0 | AssertLockHeld(::cs_main); |
361 | 0 | const CTransaction& tx = it->GetTx(); |
362 | | |
363 | | // The transaction must be final. |
364 | 0 | if (!CheckFinalTxAtTip(*Assert(m_chain.Tip()), tx)) return true; Branch (364:13): [True: 0, False: 0]
|
365 | | |
366 | 0 | const LockPoints& lp = it->GetLockPoints(); |
367 | | // CheckSequenceLocksAtTip checks if the transaction will be final in the next block to be |
368 | | // created on top of the new chain. |
369 | 0 | if (TestLockPointValidity(m_chain, lp)) { Branch (369:13): [True: 0, False: 0]
|
370 | 0 | if (!CheckSequenceLocksAtTip(m_chain.Tip(), lp)) { Branch (370:17): [True: 0, False: 0]
|
371 | 0 | return true; |
372 | 0 | } |
373 | 0 | } else { |
374 | 0 | const CCoinsViewMemPool view_mempool{&CoinsTip(), *m_mempool}; |
375 | 0 | const std::optional<LockPoints> new_lock_points{CalculateLockPointsAtTip(m_chain.Tip(), view_mempool, tx)}; |
376 | 0 | if (new_lock_points.has_value() && CheckSequenceLocksAtTip(m_chain.Tip(), *new_lock_points)) { Branch (376:17): [True: 0, False: 0]
Branch (376:48): [True: 0, False: 0]
|
377 | | // Now update the mempool entry lockpoints as well. |
378 | 0 | it->UpdateLockPoints(*new_lock_points); |
379 | 0 | } else { |
380 | 0 | return true; |
381 | 0 | } |
382 | 0 | } |
383 | | |
384 | | // If the transaction spends any coinbase outputs, it must be mature. |
385 | 0 | if (it->GetSpendsCoinbase()) { Branch (385:13): [True: 0, False: 0]
|
386 | 0 | for (const CTxIn& txin : tx.vin) { Branch (386:36): [True: 0, False: 0]
|
387 | 0 | if (m_mempool->exists(GenTxid::Txid(txin.prevout.hash))) continue; Branch (387:21): [True: 0, False: 0]
|
388 | 0 | const Coin& coin{CoinsTip().AccessCoin(txin.prevout)}; |
389 | 0 | assert(!coin.IsSpent()); |
390 | 0 | const auto mempool_spend_height{m_chain.Tip()->nHeight + 1}; |
391 | 0 | if (coin.IsCoinBase() && mempool_spend_height - coin.nHeight < COINBASE_MATURITY) { Branch (391:21): [True: 0, False: 0]
Branch (391:42): [True: 0, False: 0]
|
392 | 0 | return true; |
393 | 0 | } |
394 | 0 | } |
395 | 0 | } |
396 | | // Transaction is still valid and cached LockPoints are updated. |
397 | 0 | return false; |
398 | 0 | }; |
399 | | |
400 | | // We also need to remove any now-immature transactions |
401 | 0 | m_mempool->removeForReorg(m_chain, filter_final_and_mature); |
402 | | // Re-limit mempool size, in case we added any transactions |
403 | 0 | LimitMempoolSize(*m_mempool, this->CoinsTip()); |
404 | 0 | } |
405 | | |
406 | | /** |
407 | | * Checks to avoid mempool polluting consensus critical paths since cached |
408 | | * signature and script validity results will be reused if we validate this |
409 | | * transaction again during block validation. |
410 | | * */ |
411 | | static bool CheckInputsFromMempoolAndCache(const CTransaction& tx, TxValidationState& state, |
412 | | const CCoinsViewCache& view, const CTxMemPool& pool, |
413 | | unsigned int flags, PrecomputedTransactionData& txdata, CCoinsViewCache& coins_tip, |
414 | | ValidationCache& validation_cache) |
415 | | EXCLUSIVE_LOCKS_REQUIRED(cs_main, pool.cs) |
416 | 0 | { |
417 | 0 | AssertLockHeld(cs_main); |
418 | 0 | AssertLockHeld(pool.cs); |
419 | |
|
420 | 0 | assert(!tx.IsCoinBase()); |
421 | 0 | for (const CTxIn& txin : tx.vin) { Branch (421:28): [True: 0, False: 0]
|
422 | 0 | const Coin& coin = view.AccessCoin(txin.prevout); |
423 | | |
424 | | // This coin was checked in PreChecks and MemPoolAccept |
425 | | // has been holding cs_main since then. |
426 | 0 | Assume(!coin.IsSpent()); |
427 | 0 | if (coin.IsSpent()) return false; Branch (427:13): [True: 0, False: 0]
|
428 | | |
429 | | // If the Coin is available, there are 2 possibilities: |
430 | | // it is available in our current ChainstateActive UTXO set, |
431 | | // or it's a UTXO provided by a transaction in our mempool. |
432 | | // Ensure the scriptPubKeys in Coins from CoinsView are correct. |
433 | 0 | const CTransactionRef& txFrom = pool.get(txin.prevout.hash); |
434 | 0 | if (txFrom) { Branch (434:13): [True: 0, False: 0]
|
435 | 0 | assert(txFrom->GetHash() == txin.prevout.hash); |
436 | 0 | assert(txFrom->vout.size() > txin.prevout.n); |
437 | 0 | assert(txFrom->vout[txin.prevout.n] == coin.out); |
438 | 0 | } else { |
439 | 0 | const Coin& coinFromUTXOSet = coins_tip.AccessCoin(txin.prevout); |
440 | 0 | assert(!coinFromUTXOSet.IsSpent()); |
441 | 0 | assert(coinFromUTXOSet.out == coin.out); |
442 | 0 | } |
443 | 0 | } |
444 | | |
445 | | // Call CheckInputScripts() to cache signature and script validity against current tip consensus rules. |
446 | 0 | return CheckInputScripts(tx, state, view, flags, /* cacheSigStore= */ true, /* cacheFullScriptStore= */ true, txdata, validation_cache); |
447 | 0 | } |
448 | | |
449 | | namespace { |
450 | | |
451 | | class MemPoolAccept |
452 | | { |
453 | | public: |
454 | | explicit MemPoolAccept(CTxMemPool& mempool, Chainstate& active_chainstate) : |
455 | 0 | m_pool(mempool), |
456 | 0 | m_view(&m_dummy), |
457 | 0 | m_viewmempool(&active_chainstate.CoinsTip(), m_pool), |
458 | 0 | m_active_chainstate(active_chainstate) |
459 | 0 | { |
460 | 0 | } |
461 | | |
462 | | // We put the arguments we're handed into a struct, so we can pass them |
463 | | // around easier. |
464 | | struct ATMPArgs { |
465 | | const CChainParams& m_chainparams; |
466 | | const int64_t m_accept_time; |
467 | | const bool m_bypass_limits; |
468 | | /* |
469 | | * Return any outpoints which were not previously present in the coins |
470 | | * cache, but were added as a result of validating the tx for mempool |
471 | | * acceptance. This allows the caller to optionally remove the cache |
472 | | * additions if the associated transaction ends up being rejected by |
473 | | * the mempool. |
474 | | */ |
475 | | std::vector<COutPoint>& m_coins_to_uncache; |
476 | | /** When true, the transaction or package will not be submitted to the mempool. */ |
477 | | const bool m_test_accept; |
478 | | /** Whether we allow transactions to replace mempool transactions. If false, |
479 | | * any transaction spending the same inputs as a transaction in the mempool is considered |
480 | | * a conflict. */ |
481 | | const bool m_allow_replacement; |
482 | | /** When true, allow sibling eviction. This only occurs in single transaction package settings. */ |
483 | | const bool m_allow_sibling_eviction; |
484 | | /** When true, the mempool will not be trimmed when any transactions are submitted in |
485 | | * Finalize(). Instead, limits should be enforced at the end to ensure the package is not |
486 | | * partially submitted. |
487 | | */ |
488 | | const bool m_package_submission; |
489 | | /** When true, use package feerates instead of individual transaction feerates for fee-based |
490 | | * policies such as mempool min fee and min relay fee. |
491 | | */ |
492 | | const bool m_package_feerates; |
493 | | /** Used for local submission of transactions to catch "absurd" fees |
494 | | * due to fee miscalculation by wallets. std:nullopt implies unset, allowing any feerates. |
495 | | * Any individual transaction failing this check causes immediate failure. |
496 | | */ |
497 | | const std::optional<CFeeRate> m_client_maxfeerate; |
498 | | |
499 | | /** Whether CPFP carveout and RBF carveout are granted. */ |
500 | | const bool m_allow_carveouts; |
501 | | |
502 | | /** Parameters for single transaction mempool validation. */ |
503 | | static ATMPArgs SingleAccept(const CChainParams& chainparams, int64_t accept_time, |
504 | | bool bypass_limits, std::vector<COutPoint>& coins_to_uncache, |
505 | 0 | bool test_accept) { |
506 | 0 | return ATMPArgs{/* m_chainparams */ chainparams, |
507 | 0 | /* m_accept_time */ accept_time, |
508 | 0 | /* m_bypass_limits */ bypass_limits, |
509 | 0 | /* m_coins_to_uncache */ coins_to_uncache, |
510 | 0 | /* m_test_accept */ test_accept, |
511 | 0 | /* m_allow_replacement */ true, |
512 | 0 | /* m_allow_sibling_eviction */ true, |
513 | 0 | /* m_package_submission */ false, |
514 | 0 | /* m_package_feerates */ false, |
515 | 0 | /* m_client_maxfeerate */ {}, // checked by caller |
516 | 0 | /* m_allow_carveouts */ true, |
517 | 0 | }; |
518 | 0 | } |
519 | | |
520 | | /** Parameters for test package mempool validation through testmempoolaccept. */ |
521 | | static ATMPArgs PackageTestAccept(const CChainParams& chainparams, int64_t accept_time, |
522 | 0 | std::vector<COutPoint>& coins_to_uncache) { |
523 | 0 | return ATMPArgs{/* m_chainparams */ chainparams, |
524 | 0 | /* m_accept_time */ accept_time, |
525 | 0 | /* m_bypass_limits */ false, |
526 | 0 | /* m_coins_to_uncache */ coins_to_uncache, |
527 | 0 | /* m_test_accept */ true, |
528 | 0 | /* m_allow_replacement */ false, |
529 | 0 | /* m_allow_sibling_eviction */ false, |
530 | 0 | /* m_package_submission */ false, // not submitting to mempool |
531 | 0 | /* m_package_feerates */ false, |
532 | 0 | /* m_client_maxfeerate */ {}, // checked by caller |
533 | 0 | /* m_allow_carveouts */ false, |
534 | 0 | }; |
535 | 0 | } |
536 | | |
537 | | /** Parameters for child-with-unconfirmed-parents package validation. */ |
538 | | static ATMPArgs PackageChildWithParents(const CChainParams& chainparams, int64_t accept_time, |
539 | 0 | std::vector<COutPoint>& coins_to_uncache, const std::optional<CFeeRate>& client_maxfeerate) { |
540 | 0 | return ATMPArgs{/* m_chainparams */ chainparams, |
541 | 0 | /* m_accept_time */ accept_time, |
542 | 0 | /* m_bypass_limits */ false, |
543 | 0 | /* m_coins_to_uncache */ coins_to_uncache, |
544 | 0 | /* m_test_accept */ false, |
545 | 0 | /* m_allow_replacement */ true, |
546 | 0 | /* m_allow_sibling_eviction */ false, |
547 | 0 | /* m_package_submission */ true, |
548 | 0 | /* m_package_feerates */ true, |
549 | 0 | /* m_client_maxfeerate */ client_maxfeerate, |
550 | 0 | /* m_allow_carveouts */ false, |
551 | 0 | }; |
552 | 0 | } |
553 | | |
554 | | /** Parameters for a single transaction within a package. */ |
555 | 0 | static ATMPArgs SingleInPackageAccept(const ATMPArgs& package_args) { |
556 | 0 | return ATMPArgs{/* m_chainparams */ package_args.m_chainparams, |
557 | 0 | /* m_accept_time */ package_args.m_accept_time, |
558 | 0 | /* m_bypass_limits */ false, |
559 | 0 | /* m_coins_to_uncache */ package_args.m_coins_to_uncache, |
560 | 0 | /* m_test_accept */ package_args.m_test_accept, |
561 | 0 | /* m_allow_replacement */ true, |
562 | 0 | /* m_allow_sibling_eviction */ true, |
563 | 0 | /* m_package_submission */ true, // do not LimitMempoolSize in Finalize() |
564 | 0 | /* m_package_feerates */ false, // only 1 transaction |
565 | 0 | /* m_client_maxfeerate */ package_args.m_client_maxfeerate, |
566 | 0 | /* m_allow_carveouts */ false, |
567 | 0 | }; |
568 | 0 | } |
569 | | |
570 | | private: |
571 | | // Private ctor to avoid exposing details to clients and allowing the possibility of |
572 | | // mixing up the order of the arguments. Use static functions above instead. |
573 | | ATMPArgs(const CChainParams& chainparams, |
574 | | int64_t accept_time, |
575 | | bool bypass_limits, |
576 | | std::vector<COutPoint>& coins_to_uncache, |
577 | | bool test_accept, |
578 | | bool allow_replacement, |
579 | | bool allow_sibling_eviction, |
580 | | bool package_submission, |
581 | | bool package_feerates, |
582 | | std::optional<CFeeRate> client_maxfeerate, |
583 | | bool allow_carveouts) |
584 | 0 | : m_chainparams{chainparams}, |
585 | 0 | m_accept_time{accept_time}, |
586 | 0 | m_bypass_limits{bypass_limits}, |
587 | 0 | m_coins_to_uncache{coins_to_uncache}, |
588 | 0 | m_test_accept{test_accept}, |
589 | 0 | m_allow_replacement{allow_replacement}, |
590 | 0 | m_allow_sibling_eviction{allow_sibling_eviction}, |
591 | 0 | m_package_submission{package_submission}, |
592 | 0 | m_package_feerates{package_feerates}, |
593 | 0 | m_client_maxfeerate{client_maxfeerate}, |
594 | 0 | m_allow_carveouts{allow_carveouts} |
595 | 0 | { |
596 | | // If we are using package feerates, we must be doing package submission. |
597 | | // It also means carveouts and sibling eviction are not permitted. |
598 | 0 | if (m_package_feerates) { Branch (598:17): [True: 0, False: 0]
|
599 | 0 | Assume(m_package_submission); |
600 | 0 | Assume(!m_allow_carveouts); |
601 | 0 | Assume(!m_allow_sibling_eviction); |
602 | 0 | } |
603 | 0 | if (m_allow_sibling_eviction) Assume(m_allow_replacement); Branch (603:17): [True: 0, False: 0]
|
604 | 0 | } |
605 | | }; |
606 | | |
607 | | /** Clean up all non-chainstate coins from m_view and m_viewmempool. */ |
608 | | void CleanupTemporaryCoins() EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs); |
609 | | |
610 | | // Single transaction acceptance |
611 | | MempoolAcceptResult AcceptSingleTransaction(const CTransactionRef& ptx, ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main); |
612 | | |
613 | | /** |
614 | | * Multiple transaction acceptance. Transactions may or may not be interdependent, but must not |
615 | | * conflict with each other, and the transactions cannot already be in the mempool. Parents must |
616 | | * come before children if any dependencies exist. |
617 | | */ |
618 | | PackageMempoolAcceptResult AcceptMultipleTransactions(const std::vector<CTransactionRef>& txns, ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main); |
619 | | |
620 | | /** |
621 | | * Submission of a subpackage. |
622 | | * If subpackage size == 1, calls AcceptSingleTransaction() with adjusted ATMPArgs to avoid |
623 | | * package policy restrictions like no CPFP carve out (PackageMempoolChecks) |
624 | | * and creates a PackageMempoolAcceptResult wrapping the result. |
625 | | * |
626 | | * If subpackage size > 1, calls AcceptMultipleTransactions() with the provided ATMPArgs. |
627 | | * |
628 | | * Also cleans up all non-chainstate coins from m_view at the end. |
629 | | */ |
630 | | PackageMempoolAcceptResult AcceptSubPackage(const std::vector<CTransactionRef>& subpackage, ATMPArgs& args) |
631 | | EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs); |
632 | | |
633 | | /** |
634 | | * Package (more specific than just multiple transactions) acceptance. Package must be a child |
635 | | * with all of its unconfirmed parents, and topologically sorted. |
636 | | */ |
637 | | PackageMempoolAcceptResult AcceptPackage(const Package& package, ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main); |
638 | | |
639 | | private: |
640 | | // All the intermediate state that gets passed between the various levels |
641 | | // of checking a given transaction. |
642 | | struct Workspace { |
643 | 0 | explicit Workspace(const CTransactionRef& ptx) : m_ptx(ptx), m_hash(ptx->GetHash()) {} |
644 | | /** Txids of mempool transactions that this transaction directly conflicts with or may |
645 | | * replace via sibling eviction. */ |
646 | | std::set<Txid> m_conflicts; |
647 | | /** Iterators to mempool entries that this transaction directly conflicts with or may |
648 | | * replace via sibling eviction. */ |
649 | | CTxMemPool::setEntries m_iters_conflicting; |
650 | | /** All mempool ancestors of this transaction. */ |
651 | | CTxMemPool::setEntries m_ancestors; |
652 | | /** Mempool entry constructed for this transaction. Constructed in PreChecks() but not |
653 | | * inserted into the mempool until Finalize(). */ |
654 | | std::unique_ptr<CTxMemPoolEntry> m_entry; |
655 | | /** Whether RBF-related data structures (m_conflicts, m_iters_conflicting, m_all_conflicting, |
656 | | * m_replaced_transactions) include a sibling in addition to txns with conflicting inputs. */ |
657 | | bool m_sibling_eviction{false}; |
658 | | |
659 | | /** Virtual size of the transaction as used by the mempool, calculated using serialized size |
660 | | * of the transaction and sigops. */ |
661 | | int64_t m_vsize; |
662 | | /** Fees paid by this transaction: total input amounts subtracted by total output amounts. */ |
663 | | CAmount m_base_fees; |
664 | | /** Base fees + any fee delta set by the user with prioritisetransaction. */ |
665 | | CAmount m_modified_fees; |
666 | | |
667 | | /** If we're doing package validation (i.e. m_package_feerates=true), the "effective" |
668 | | * package feerate of this transaction is the total fees divided by the total size of |
669 | | * transactions (which may include its ancestors and/or descendants). */ |
670 | | CFeeRate m_package_feerate{0}; |
671 | | |
672 | | const CTransactionRef& m_ptx; |
673 | | /** Txid. */ |
674 | | const Txid& m_hash; |
675 | | TxValidationState m_state; |
676 | | /** A temporary cache containing serialized transaction data for signature verification. |
677 | | * Reused across PolicyScriptChecks and ConsensusScriptChecks. */ |
678 | | PrecomputedTransactionData m_precomputed_txdata; |
679 | | }; |
680 | | |
681 | | // Run the policy checks on a given transaction, excluding any script checks. |
682 | | // Looks up inputs, calculates feerate, considers replacement, evaluates |
683 | | // package limits, etc. As this function can be invoked for "free" by a peer, |
684 | | // only tests that are fast should be done here (to avoid CPU DoS). |
685 | | bool PreChecks(ATMPArgs& args, Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs); |
686 | | |
687 | | // Run checks for mempool replace-by-fee, only used in AcceptSingleTransaction. |
688 | | bool ReplacementChecks(Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs); |
689 | | |
690 | | // Enforce package mempool ancestor/descendant limits (distinct from individual |
691 | | // ancestor/descendant limits done in PreChecks) and run Package RBF checks. |
692 | | bool PackageMempoolChecks(const std::vector<CTransactionRef>& txns, |
693 | | std::vector<Workspace>& workspaces, |
694 | | int64_t total_vsize, |
695 | | PackageValidationState& package_state) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs); |
696 | | |
697 | | // Run the script checks using our policy flags. As this can be slow, we should |
698 | | // only invoke this on transactions that have otherwise passed policy checks. |
699 | | bool PolicyScriptChecks(const ATMPArgs& args, Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs); |
700 | | |
701 | | // Re-run the script checks, using consensus flags, and try to cache the |
702 | | // result in the scriptcache. This should be done after |
703 | | // PolicyScriptChecks(). This requires that all inputs either be in our |
704 | | // utxo set or in the mempool. |
705 | | bool ConsensusScriptChecks(const ATMPArgs& args, Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs); |
706 | | |
707 | | // Try to add the transaction to the mempool, removing any conflicts first. |
708 | | // Returns true if the transaction is in the mempool after any size |
709 | | // limiting is performed, false otherwise. |
710 | | bool Finalize(const ATMPArgs& args, Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs); |
711 | | |
712 | | // Submit all transactions to the mempool and call ConsensusScriptChecks to add to the script |
713 | | // cache - should only be called after successful validation of all transactions in the package. |
714 | | // Does not call LimitMempoolSize(), so mempool max_size_bytes may be temporarily exceeded. |
715 | | bool SubmitPackage(const ATMPArgs& args, std::vector<Workspace>& workspaces, PackageValidationState& package_state, |
716 | | std::map<uint256, MempoolAcceptResult>& results) |
717 | | EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs); |
718 | | |
719 | | // Compare a package's feerate against minimum allowed. |
720 | | bool CheckFeeRate(size_t package_size, CAmount package_fee, TxValidationState& state) EXCLUSIVE_LOCKS_REQUIRED(::cs_main, m_pool.cs) |
721 | 0 | { |
722 | 0 | AssertLockHeld(::cs_main); |
723 | 0 | AssertLockHeld(m_pool.cs); |
724 | 0 | CAmount mempoolRejectFee = m_pool.GetMinFee().GetFee(package_size); |
725 | 0 | if (mempoolRejectFee > 0 && package_fee < mempoolRejectFee) { Branch (725:13): [True: 0, False: 0]
Branch (725:37): [True: 0, False: 0]
|
726 | 0 | return state.Invalid(TxValidationResult::TX_RECONSIDERABLE, "mempool min fee not met", strprintf("%d < %d", package_fee, mempoolRejectFee)); |
727 | 0 | } |
728 | | |
729 | 0 | if (package_fee < m_pool.m_opts.min_relay_feerate.GetFee(package_size)) { Branch (729:13): [True: 0, False: 0]
|
730 | 0 | return state.Invalid(TxValidationResult::TX_RECONSIDERABLE, "min relay fee not met", |
731 | 0 | strprintf("%d < %d", package_fee, m_pool.m_opts.min_relay_feerate.GetFee(package_size))); |
732 | 0 | } |
733 | 0 | return true; |
734 | 0 | } |
735 | | |
736 | | ValidationCache& GetValidationCache() |
737 | 0 | { |
738 | 0 | return m_active_chainstate.m_chainman.m_validation_cache; |
739 | 0 | } |
740 | | |
741 | | private: |
742 | | CTxMemPool& m_pool; |
743 | | CCoinsViewCache m_view; |
744 | | CCoinsViewMemPool m_viewmempool; |
745 | | CCoinsView m_dummy; |
746 | | |
747 | | Chainstate& m_active_chainstate; |
748 | | |
749 | | // Fields below are per *sub*package state and must be reset prior to subsequent |
750 | | // AcceptSingleTransaction and AcceptMultipleTransactions invocations |
751 | | struct SubPackageState { |
752 | | /** Aggregated modified fees of all transactions, used to calculate package feerate. */ |
753 | | CAmount m_total_modified_fees{0}; |
754 | | /** Aggregated virtual size of all transactions, used to calculate package feerate. */ |
755 | | int64_t m_total_vsize{0}; |
756 | | |
757 | | // RBF-related members |
758 | | /** Whether the transaction(s) would replace any mempool transactions and/or evict any siblings. |
759 | | * If so, RBF rules apply. */ |
760 | | bool m_rbf{false}; |
761 | | /** All directly conflicting mempool transactions and their descendants. */ |
762 | | CTxMemPool::setEntries m_all_conflicts; |
763 | | /** Mempool transactions that were replaced. */ |
764 | | std::list<CTransactionRef> m_replaced_transactions; |
765 | | |
766 | | /** Total modified fees of mempool transactions being replaced. */ |
767 | | CAmount m_conflicting_fees{0}; |
768 | | /** Total size (in virtual bytes) of mempool transactions being replaced. */ |
769 | | size_t m_conflicting_size{0}; |
770 | | }; |
771 | | |
772 | | struct SubPackageState m_subpackage; |
773 | | |
774 | | /** Re-set sub-package state to not leak between evaluations */ |
775 | | void ClearSubPackageState() EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs) |
776 | 0 | { |
777 | 0 | m_subpackage = SubPackageState{}; |
778 | | |
779 | | // And clean coins while at it |
780 | 0 | CleanupTemporaryCoins(); |
781 | 0 | } |
782 | | }; |
783 | | |
784 | | bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws) |
785 | 0 | { |
786 | 0 | AssertLockHeld(cs_main); |
787 | 0 | AssertLockHeld(m_pool.cs); |
788 | 0 | const CTransactionRef& ptx = ws.m_ptx; |
789 | 0 | const CTransaction& tx = *ws.m_ptx; |
790 | 0 | const Txid& hash = ws.m_hash; |
791 | | |
792 | | // Copy/alias what we need out of args |
793 | 0 | const int64_t nAcceptTime = args.m_accept_time; |
794 | 0 | const bool bypass_limits = args.m_bypass_limits; |
795 | 0 | std::vector<COutPoint>& coins_to_uncache = args.m_coins_to_uncache; |
796 | | |
797 | | // Alias what we need out of ws |
798 | 0 | TxValidationState& state = ws.m_state; |
799 | 0 | std::unique_ptr<CTxMemPoolEntry>& entry = ws.m_entry; |
800 | |
|
801 | 0 | if (!CheckTransaction(tx, state)) { Branch (801:9): [True: 0, False: 0]
|
802 | 0 | return false; // state filled in by CheckTransaction |
803 | 0 | } |
804 | | |
805 | | // Coinbase is only valid in a block, not as a loose transaction |
806 | 0 | if (tx.IsCoinBase()) Branch (806:9): [True: 0, False: 0]
|
807 | 0 | return state.Invalid(TxValidationResult::TX_CONSENSUS, "coinbase"); |
808 | | |
809 | | // Rather not work on nonstandard transactions (unless -testnet/-regtest) |
810 | 0 | std::string reason; |
811 | 0 | if (m_pool.m_opts.require_standard && !IsStandardTx(tx, m_pool.m_opts.max_datacarrier_bytes, m_pool.m_opts.permit_bare_multisig, m_pool.m_opts.dust_relay_feerate, reason)) { Branch (811:9): [True: 0, False: 0]
Branch (811:43): [True: 0, False: 0]
|
812 | 0 | return state.Invalid(TxValidationResult::TX_NOT_STANDARD, reason); |
813 | 0 | } |
814 | | |
815 | | // Transactions smaller than 65 non-witness bytes are not relayed to mitigate CVE-2017-12842. |
816 | 0 | if (::GetSerializeSize(TX_NO_WITNESS(tx)) < MIN_STANDARD_TX_NONWITNESS_SIZE) Branch (816:9): [True: 0, False: 0]
|
817 | 0 | return state.Invalid(TxValidationResult::TX_NOT_STANDARD, "tx-size-small"); |
818 | | |
819 | | // Only accept nLockTime-using transactions that can be mined in the next |
820 | | // block; we don't want our mempool filled up with transactions that can't |
821 | | // be mined yet. |
822 | 0 | if (!CheckFinalTxAtTip(*Assert(m_active_chainstate.m_chain.Tip()), tx)) { Branch (822:9): [True: 0, False: 0]
|
823 | 0 | return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "non-final"); |
824 | 0 | } |
825 | | |
826 | 0 | if (m_pool.exists(GenTxid::Wtxid(tx.GetWitnessHash()))) { Branch (826:9): [True: 0, False: 0]
|
827 | | // Exact transaction already exists in the mempool. |
828 | 0 | return state.Invalid(TxValidationResult::TX_CONFLICT, "txn-already-in-mempool"); |
829 | 0 | } else if (m_pool.exists(GenTxid::Txid(tx.GetHash()))) { Branch (829:16): [True: 0, False: 0]
|
830 | | // Transaction with the same non-witness data but different witness (same txid, different |
831 | | // wtxid) already exists in the mempool. |
832 | 0 | return state.Invalid(TxValidationResult::TX_CONFLICT, "txn-same-nonwitness-data-in-mempool"); |
833 | 0 | } |
834 | | |
835 | | // Check for conflicts with in-memory transactions |
836 | 0 | for (const CTxIn &txin : tx.vin) Branch (836:28): [True: 0, False: 0]
|
837 | 0 | { |
838 | 0 | const CTransaction* ptxConflicting = m_pool.GetConflictTx(txin.prevout); |
839 | 0 | if (ptxConflicting) { Branch (839:13): [True: 0, False: 0]
|
840 | 0 | if (!args.m_allow_replacement) { Branch (840:17): [True: 0, False: 0]
|
841 | | // Transaction conflicts with a mempool tx, but we're not allowing replacements. |
842 | 0 | return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "bip125-replacement-disallowed"); |
843 | 0 | } |
844 | 0 | if (!ws.m_conflicts.count(ptxConflicting->GetHash())) Branch (844:17): [True: 0, False: 0]
|
845 | 0 | { |
846 | | // Transactions that don't explicitly signal replaceability are |
847 | | // *not* replaceable with the current logic, even if one of their |
848 | | // unconfirmed ancestors signals replaceability. This diverges |
849 | | // from BIP125's inherited signaling description (see CVE-2021-31876). |
850 | | // Applications relying on first-seen mempool behavior should |
851 | | // check all unconfirmed ancestors; otherwise an opt-in ancestor |
852 | | // might be replaced, causing removal of this descendant. |
853 | | // |
854 | | // All TRUC transactions are considered replaceable. |
855 | | // |
856 | | // Replaceability signaling of the original transactions may be |
857 | | // ignored due to node setting. |
858 | 0 | const bool allow_rbf{m_pool.m_opts.full_rbf || SignalsOptInRBF(*ptxConflicting) || ptxConflicting->version == TRUC_VERSION}; Branch (858:38): [True: 0, False: 0]
Branch (858:64): [True: 0, False: 0]
Branch (858:100): [True: 0, False: 0]
|
859 | 0 | if (!allow_rbf) { Branch (859:21): [True: 0, False: 0]
|
860 | 0 | return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "txn-mempool-conflict"); |
861 | 0 | } |
862 | | |
863 | 0 | ws.m_conflicts.insert(ptxConflicting->GetHash()); |
864 | 0 | } |
865 | 0 | } |
866 | 0 | } |
867 | | |
868 | 0 | m_view.SetBackend(m_viewmempool); |
869 | |
|
870 | 0 | const CCoinsViewCache& coins_cache = m_active_chainstate.CoinsTip(); |
871 | | // do all inputs exist? |
872 | 0 | for (const CTxIn& txin : tx.vin) { Branch (872:28): [True: 0, False: 0]
|
873 | 0 | if (!coins_cache.HaveCoinInCache(txin.prevout)) { Branch (873:13): [True: 0, False: 0]
|
874 | 0 | coins_to_uncache.push_back(txin.prevout); |
875 | 0 | } |
876 | | |
877 | | // Note: this call may add txin.prevout to the coins cache |
878 | | // (coins_cache.cacheCoins) by way of FetchCoin(). It should be removed |
879 | | // later (via coins_to_uncache) if this tx turns out to be invalid. |
880 | 0 | if (!m_view.HaveCoin(txin.prevout)) { Branch (880:13): [True: 0, False: 0]
|
881 | | // Are inputs missing because we already have the tx? |
882 | 0 | for (size_t out = 0; out < tx.vout.size(); out++) { Branch (882:34): [True: 0, False: 0]
|
883 | | // Optimistically just do efficient check of cache for outputs |
884 | 0 | if (coins_cache.HaveCoinInCache(COutPoint(hash, out))) { Branch (884:21): [True: 0, False: 0]
|
885 | 0 | return state.Invalid(TxValidationResult::TX_CONFLICT, "txn-already-known"); |
886 | 0 | } |
887 | 0 | } |
888 | | // Otherwise assume this might be an orphan tx for which we just haven't seen parents yet |
889 | 0 | return state.Invalid(TxValidationResult::TX_MISSING_INPUTS, "bad-txns-inputs-missingorspent"); |
890 | 0 | } |
891 | 0 | } |
892 | | |
893 | | // This is const, but calls into the back end CoinsViews. The CCoinsViewDB at the bottom of the |
894 | | // hierarchy brings the best block into scope. See CCoinsViewDB::GetBestBlock(). |
895 | 0 | m_view.GetBestBlock(); |
896 | | |
897 | | // we have all inputs cached now, so switch back to dummy (to protect |
898 | | // against bugs where we pull more inputs from disk that miss being added |
899 | | // to coins_to_uncache) |
900 | 0 | m_view.SetBackend(m_dummy); |
901 | |
|
902 | 0 | assert(m_active_chainstate.m_blockman.LookupBlockIndex(m_view.GetBestBlock()) == m_active_chainstate.m_chain.Tip()); |
903 | | |
904 | | // Only accept BIP68 sequence locked transactions that can be mined in the next |
905 | | // block; we don't want our mempool filled up with transactions that can't |
906 | | // be mined yet. |
907 | | // Pass in m_view which has all of the relevant inputs cached. Note that, since m_view's |
908 | | // backend was removed, it no longer pulls coins from the mempool. |
909 | 0 | const std::optional<LockPoints> lock_points{CalculateLockPointsAtTip(m_active_chainstate.m_chain.Tip(), m_view, tx)}; |
910 | 0 | if (!lock_points.has_value() || !CheckSequenceLocksAtTip(m_active_chainstate.m_chain.Tip(), *lock_points)) { Branch (910:9): [True: 0, False: 0]
Branch (910:37): [True: 0, False: 0]
|
911 | 0 | return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "non-BIP68-final"); |
912 | 0 | } |
913 | | |
914 | | // The mempool holds txs for the next block, so pass height+1 to CheckTxInputs |
915 | 0 | if (!Consensus::CheckTxInputs(tx, state, m_view, m_active_chainstate.m_chain.Height() + 1, ws.m_base_fees)) { Branch (915:9): [True: 0, False: 0]
|
916 | 0 | return false; // state filled in by CheckTxInputs |
917 | 0 | } |
918 | | |
919 | 0 | if (m_pool.m_opts.require_standard && !AreInputsStandard(tx, m_view)) { Branch (919:9): [True: 0, False: 0]
Branch (919:43): [True: 0, False: 0]
|
920 | 0 | return state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs"); |
921 | 0 | } |
922 | | |
923 | | // Check for non-standard witnesses. |
924 | 0 | if (tx.HasWitness() && m_pool.m_opts.require_standard && !IsWitnessStandard(tx, m_view)) { Branch (924:9): [True: 0, False: 0]
Branch (924:28): [True: 0, False: 0]
Branch (924:62): [True: 0, False: 0]
|
925 | 0 | return state.Invalid(TxValidationResult::TX_WITNESS_MUTATED, "bad-witness-nonstandard"); |
926 | 0 | } |
927 | | |
928 | 0 | int64_t nSigOpsCost = GetTransactionSigOpCost(tx, m_view, STANDARD_SCRIPT_VERIFY_FLAGS); |
929 | | |
930 | | // ws.m_modified_fees includes any fee deltas from PrioritiseTransaction |
931 | 0 | ws.m_modified_fees = ws.m_base_fees; |
932 | 0 | m_pool.ApplyDelta(hash, ws.m_modified_fees); |
933 | | |
934 | | // Keep track of transactions that spend a coinbase, which we re-scan |
935 | | // during reorgs to ensure COINBASE_MATURITY is still met. |
936 | 0 | bool fSpendsCoinbase = false; |
937 | 0 | for (const CTxIn &txin : tx.vin) { Branch (937:28): [True: 0, False: 0]
|
938 | 0 | const Coin &coin = m_view.AccessCoin(txin.prevout); |
939 | 0 | if (coin.IsCoinBase()) { Branch (939:13): [True: 0, False: 0]
|
940 | 0 | fSpendsCoinbase = true; |
941 | 0 | break; |
942 | 0 | } |
943 | 0 | } |
944 | | |
945 | | // Set entry_sequence to 0 when bypass_limits is used; this allows txs from a block |
946 | | // reorg to be marked earlier than any child txs that were already in the mempool. |
947 | 0 | const uint64_t entry_sequence = bypass_limits ? 0 : m_pool.GetSequence(); Branch (947:37): [True: 0, False: 0]
|
948 | 0 | entry.reset(new CTxMemPoolEntry(ptx, ws.m_base_fees, nAcceptTime, m_active_chainstate.m_chain.Height(), entry_sequence, |
949 | 0 | fSpendsCoinbase, nSigOpsCost, lock_points.value())); |
950 | 0 | ws.m_vsize = entry->GetTxSize(); |
951 | |
|
952 | 0 | if (nSigOpsCost > MAX_STANDARD_TX_SIGOPS_COST) Branch (952:9): [True: 0, False: 0]
|
953 | 0 | return state.Invalid(TxValidationResult::TX_NOT_STANDARD, "bad-txns-too-many-sigops", |
954 | 0 | strprintf("%d", nSigOpsCost)); |
955 | | |
956 | | // No individual transactions are allowed below the min relay feerate except from disconnected blocks. |
957 | | // This requirement, unlike CheckFeeRate, cannot be bypassed using m_package_feerates because, |
958 | | // while a tx could be package CPFP'd when entering the mempool, we do not have a DoS-resistant |
959 | | // method of ensuring the tx remains bumped. For example, the fee-bumping child could disappear |
960 | | // due to a replacement. |
961 | | // The only exception is TRUC transactions. |
962 | 0 | if (!bypass_limits && ws.m_ptx->version != TRUC_VERSION && ws.m_modified_fees < m_pool.m_opts.min_relay_feerate.GetFee(ws.m_vsize)) { Branch (962:9): [True: 0, False: 0]
Branch (962:27): [True: 0, False: 0]
Branch (962:64): [True: 0, False: 0]
|
963 | | // Even though this is a fee-related failure, this result is TX_MEMPOOL_POLICY, not |
964 | | // TX_RECONSIDERABLE, because it cannot be bypassed using package validation. |
965 | 0 | return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "min relay fee not met", |
966 | 0 | strprintf("%d < %d", ws.m_modified_fees, m_pool.m_opts.min_relay_feerate.GetFee(ws.m_vsize))); |
967 | 0 | } |
968 | | // No individual transactions are allowed below the mempool min feerate except from disconnected |
969 | | // blocks and transactions in a package. Package transactions will be checked using package |
970 | | // feerate later. |
971 | 0 | if (!bypass_limits && !args.m_package_feerates && !CheckFeeRate(ws.m_vsize, ws.m_modified_fees, state)) return false; Branch (971:9): [True: 0, False: 0]
Branch (971:27): [True: 0, False: 0]
Branch (971:55): [True: 0, False: 0]
|
972 | | |
973 | 0 | ws.m_iters_conflicting = m_pool.GetIterSet(ws.m_conflicts); |
974 | | |
975 | | // Note that these modifications are only applicable to single transaction scenarios; |
976 | | // carve-outs are disabled for multi-transaction evaluations. |
977 | 0 | CTxMemPool::Limits maybe_rbf_limits = m_pool.m_opts.limits; |
978 | | |
979 | | // Calculate in-mempool ancestors, up to a limit. |
980 | 0 | if (ws.m_conflicts.size() == 1 && args.m_allow_carveouts) { Branch (980:9): [True: 0, False: 0]
Branch (980:39): [True: 0, False: 0]
|
981 | | // In general, when we receive an RBF transaction with mempool conflicts, we want to know whether we |
982 | | // would meet the chain limits after the conflicts have been removed. However, there isn't a practical |
983 | | // way to do this short of calculating the ancestor and descendant sets with an overlay cache of |
984 | | // changed mempool entries. Due to both implementation and runtime complexity concerns, this isn't |
985 | | // very realistic, thus we only ensure a limited set of transactions are RBF'able despite mempool |
986 | | // conflicts here. Importantly, we need to ensure that some transactions which were accepted using |
987 | | // the below carve-out are able to be RBF'ed, without impacting the security the carve-out provides |
988 | | // for off-chain contract systems (see link in the comment below). |
989 | | // |
990 | | // Specifically, the subset of RBF transactions which we allow despite chain limits are those which |
991 | | // conflict directly with exactly one other transaction (but may evict children of said transaction), |
992 | | // and which are not adding any new mempool dependencies. Note that the "no new mempool dependencies" |
993 | | // check is accomplished later, so we don't bother doing anything about it here, but if our |
994 | | // policy changes, we may need to move that check to here instead of removing it wholesale. |
995 | | // |
996 | | // Such transactions are clearly not merging any existing packages, so we are only concerned with |
997 | | // ensuring that (a) no package is growing past the package size (not count) limits and (b) we are |
998 | | // not allowing something to effectively use the (below) carve-out spot when it shouldn't be allowed |
999 | | // to. |
1000 | | // |
1001 | | // To check these we first check if we meet the RBF criteria, above, and increment the descendant |
1002 | | // limits by the direct conflict and its descendants (as these are recalculated in |
1003 | | // CalculateMempoolAncestors by assuming the new transaction being added is a new descendant, with no |
1004 | | // removals, of each parent's existing dependent set). The ancestor count limits are unmodified (as |
1005 | | // the ancestor limits should be the same for both our new transaction and any conflicts). |
1006 | | // We don't bother incrementing m_limit_descendants by the full removal count as that limit never comes |
1007 | | // into force here (as we're only adding a single transaction). |
1008 | 0 | assert(ws.m_iters_conflicting.size() == 1); |
1009 | 0 | CTxMemPool::txiter conflict = *ws.m_iters_conflicting.begin(); |
1010 | |
|
1011 | 0 | maybe_rbf_limits.descendant_count += 1; |
1012 | 0 | maybe_rbf_limits.descendant_size_vbytes += conflict->GetSizeWithDescendants(); |
1013 | 0 | } |
1014 | | |
1015 | 0 | if (auto ancestors{m_pool.CalculateMemPoolAncestors(*entry, maybe_rbf_limits)}) { Branch (1015:14): [True: 0, False: 0]
|
1016 | 0 | ws.m_ancestors = std::move(*ancestors); |
1017 | 0 | } else { |
1018 | | // If CalculateMemPoolAncestors fails second time, we want the original error string. |
1019 | 0 | const auto error_message{util::ErrorString(ancestors).original}; |
1020 | | |
1021 | | // Carve-out is not allowed in this context; fail |
1022 | 0 | if (!args.m_allow_carveouts) { Branch (1022:13): [True: 0, False: 0]
|
1023 | 0 | return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-long-mempool-chain", error_message); |
1024 | 0 | } |
1025 | | |
1026 | | // Contracting/payment channels CPFP carve-out: |
1027 | | // If the new transaction is relatively small (up to 40k weight) |
1028 | | // and has at most one ancestor (ie ancestor limit of 2, including |
1029 | | // the new transaction), allow it if its parent has exactly the |
1030 | | // descendant limit descendants. The transaction also cannot be TRUC, |
1031 | | // as its topology restrictions do not allow a second child. |
1032 | | // |
1033 | | // This allows protocols which rely on distrusting counterparties |
1034 | | // being able to broadcast descendants of an unconfirmed transaction |
1035 | | // to be secure by simply only having two immediately-spendable |
1036 | | // outputs - one for each counterparty. For more info on the uses for |
1037 | | // this, see https://lists.linuxfoundation.org/pipermail/bitcoin-dev/2018-November/016518.html |
1038 | 0 | CTxMemPool::Limits cpfp_carve_out_limits{ |
1039 | 0 | .ancestor_count = 2, |
1040 | 0 | .ancestor_size_vbytes = maybe_rbf_limits.ancestor_size_vbytes, |
1041 | 0 | .descendant_count = maybe_rbf_limits.descendant_count + 1, |
1042 | 0 | .descendant_size_vbytes = maybe_rbf_limits.descendant_size_vbytes + EXTRA_DESCENDANT_TX_SIZE_LIMIT, |
1043 | 0 | }; |
1044 | 0 | if (ws.m_vsize > EXTRA_DESCENDANT_TX_SIZE_LIMIT || ws.m_ptx->version == TRUC_VERSION) { Branch (1044:13): [True: 0, False: 0]
Branch (1044:60): [True: 0, False: 0]
|
1045 | 0 | return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-long-mempool-chain", error_message); |
1046 | 0 | } |
1047 | 0 | if (auto ancestors_retry{m_pool.CalculateMemPoolAncestors(*entry, cpfp_carve_out_limits)}) { Branch (1047:18): [True: 0, False: 0]
|
1048 | 0 | ws.m_ancestors = std::move(*ancestors_retry); |
1049 | 0 | } else { |
1050 | 0 | return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-long-mempool-chain", error_message); |
1051 | 0 | } |
1052 | 0 | } |
1053 | | |
1054 | | // Even though just checking direct mempool parents for inheritance would be sufficient, we |
1055 | | // check using the full ancestor set here because it's more convenient to use what we have |
1056 | | // already calculated. |
1057 | 0 | if (const auto err{SingleTRUCChecks(ws.m_ptx, ws.m_ancestors, ws.m_conflicts, ws.m_vsize)}) { Branch (1057:20): [True: 0, False: 0]
|
1058 | | // Single transaction contexts only. |
1059 | 0 | if (args.m_allow_sibling_eviction && err->second != nullptr) { Branch (1059:13): [True: 0, False: 0]
Branch (1059:46): [True: 0, False: 0]
|
1060 | | // We should only be considering where replacement is considered valid as well. |
1061 | 0 | Assume(args.m_allow_replacement); |
1062 | | |
1063 | | // Potential sibling eviction. Add the sibling to our list of mempool conflicts to be |
1064 | | // included in RBF checks. |
1065 | 0 | ws.m_conflicts.insert(err->second->GetHash()); |
1066 | | // Adding the sibling to m_iters_conflicting here means that it doesn't count towards |
1067 | | // RBF Carve Out above. This is correct, since removing to-be-replaced transactions from |
1068 | | // the descendant count is done separately in SingleTRUCChecks for TRUC transactions. |
1069 | 0 | ws.m_iters_conflicting.insert(m_pool.GetIter(err->second->GetHash()).value()); |
1070 | 0 | ws.m_sibling_eviction = true; |
1071 | | // The sibling will be treated as part of the to-be-replaced set in ReplacementChecks. |
1072 | | // Note that we are not checking whether it opts in to replaceability via BIP125 or TRUC |
1073 | | // (which is normally done in PreChecks). However, the only way a TRUC transaction can |
1074 | | // have a non-TRUC and non-BIP125 descendant is due to a reorg. |
1075 | 0 | } else { |
1076 | 0 | return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "TRUC-violation", err->first); |
1077 | 0 | } |
1078 | 0 | } |
1079 | | |
1080 | | // A transaction that spends outputs that would be replaced by it is invalid. Now |
1081 | | // that we have the set of all ancestors we can detect this |
1082 | | // pathological case by making sure ws.m_conflicts and ws.m_ancestors don't |
1083 | | // intersect. |
1084 | 0 | if (const auto err_string{EntriesAndTxidsDisjoint(ws.m_ancestors, ws.m_conflicts, hash)}) { Branch (1084:20): [True: 0, False: 0]
|
1085 | | // We classify this as a consensus error because a transaction depending on something it |
1086 | | // conflicts with would be inconsistent. |
1087 | 0 | return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-spends-conflicting-tx", *err_string); |
1088 | 0 | } |
1089 | | |
1090 | | // We want to detect conflicts in any tx in a package to trigger package RBF logic |
1091 | 0 | m_subpackage.m_rbf |= !ws.m_conflicts.empty(); |
1092 | 0 | return true; |
1093 | 0 | } |
1094 | | |
1095 | | bool MemPoolAccept::ReplacementChecks(Workspace& ws) |
1096 | 0 | { |
1097 | 0 | AssertLockHeld(cs_main); |
1098 | 0 | AssertLockHeld(m_pool.cs); |
1099 | |
|
1100 | 0 | const CTransaction& tx = *ws.m_ptx; |
1101 | 0 | const uint256& hash = ws.m_hash; |
1102 | 0 | TxValidationState& state = ws.m_state; |
1103 | |
|
1104 | 0 | CFeeRate newFeeRate(ws.m_modified_fees, ws.m_vsize); |
1105 | | // Enforce Rule #6. The replacement transaction must have a higher feerate than its direct conflicts. |
1106 | | // - The motivation for this check is to ensure that the replacement transaction is preferable for |
1107 | | // block-inclusion, compared to what would be removed from the mempool. |
1108 | | // - This logic predates ancestor feerate-based transaction selection, which is why it doesn't |
1109 | | // consider feerates of descendants. |
1110 | | // - Note: Ancestor feerate-based transaction selection has made this comparison insufficient to |
1111 | | // guarantee that this is incentive-compatible for miners, because it is possible for a |
1112 | | // descendant transaction of a direct conflict to pay a higher feerate than the transaction that |
1113 | | // might replace them, under these rules. |
1114 | 0 | if (const auto err_string{PaysMoreThanConflicts(ws.m_iters_conflicting, newFeeRate, hash)}) { Branch (1114:20): [True: 0, False: 0]
|
1115 | | // This fee-related failure is TX_RECONSIDERABLE because validating in a package may change |
1116 | | // the result. |
1117 | 0 | return state.Invalid(TxValidationResult::TX_RECONSIDERABLE, |
1118 | 0 | strprintf("insufficient fee%s", ws.m_sibling_eviction ? " (including sibling eviction)" : ""), *err_string); Branch (1118:62): [True: 0, False: 0]
|
1119 | 0 | } |
1120 | | |
1121 | | // Calculate all conflicting entries and enforce Rule #5. |
1122 | 0 | if (const auto err_string{GetEntriesForConflicts(tx, m_pool, ws.m_iters_conflicting, m_subpackage.m_all_conflicts)}) { Branch (1122:20): [True: 0, False: 0]
|
1123 | 0 | return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, |
1124 | 0 | strprintf("too many potential replacements%s", ws.m_sibling_eviction ? " (including sibling eviction)" : ""), *err_string); Branch (1124:77): [True: 0, False: 0]
|
1125 | 0 | } |
1126 | | // Enforce Rule #2. |
1127 | 0 | if (const auto err_string{HasNoNewUnconfirmed(tx, m_pool, m_subpackage.m_all_conflicts)}) { Branch (1127:20): [True: 0, False: 0]
|
1128 | | // Sibling eviction is only done for TRUC transactions, which cannot have multiple ancestors. |
1129 | 0 | Assume(!ws.m_sibling_eviction); |
1130 | 0 | return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, |
1131 | 0 | strprintf("replacement-adds-unconfirmed%s", ws.m_sibling_eviction ? " (including sibling eviction)" : ""), *err_string); Branch (1131:74): [True: 0, False: 0]
|
1132 | 0 | } |
1133 | | |
1134 | | // Check if it's economically rational to mine this transaction rather than the ones it |
1135 | | // replaces and pays for its own relay fees. Enforce Rules #3 and #4. |
1136 | 0 | for (CTxMemPool::txiter it : m_subpackage.m_all_conflicts) { Branch (1136:32): [True: 0, False: 0]
|
1137 | 0 | m_subpackage.m_conflicting_fees += it->GetModifiedFee(); |
1138 | 0 | m_subpackage.m_conflicting_size += it->GetTxSize(); |
1139 | 0 | } |
1140 | 0 | if (const auto err_string{PaysForRBF(m_subpackage.m_conflicting_fees, ws.m_modified_fees, ws.m_vsize, Branch (1140:20): [True: 0, False: 0]
|
1141 | 0 | m_pool.m_opts.incremental_relay_feerate, hash)}) { |
1142 | | // Result may change in a package context |
1143 | 0 | return state.Invalid(TxValidationResult::TX_RECONSIDERABLE, |
1144 | 0 | strprintf("insufficient fee%s", ws.m_sibling_eviction ? " (including sibling eviction)" : ""), *err_string); Branch (1144:62): [True: 0, False: 0]
|
1145 | 0 | } |
1146 | 0 | return true; |
1147 | 0 | } |
1148 | | |
1149 | | bool MemPoolAccept::PackageMempoolChecks(const std::vector<CTransactionRef>& txns, |
1150 | | std::vector<Workspace>& workspaces, |
1151 | | const int64_t total_vsize, |
1152 | | PackageValidationState& package_state) |
1153 | 0 | { |
1154 | 0 | AssertLockHeld(cs_main); |
1155 | 0 | AssertLockHeld(m_pool.cs); |
1156 | | |
1157 | | // CheckPackageLimits expects the package transactions to not already be in the mempool. |
1158 | 0 | assert(std::all_of(txns.cbegin(), txns.cend(), [this](const auto& tx) |
1159 | 0 | { return !m_pool.exists(GenTxid::Txid(tx->GetHash()));})); |
1160 | | |
1161 | 0 | assert(txns.size() == workspaces.size()); |
1162 | | |
1163 | 0 | auto result = m_pool.CheckPackageLimits(txns, total_vsize); |
1164 | 0 | if (!result) { Branch (1164:9): [True: 0, False: 0]
|
1165 | | // This is a package-wide error, separate from an individual transaction error. |
1166 | 0 | return package_state.Invalid(PackageValidationResult::PCKG_POLICY, "package-mempool-limits", util::ErrorString(result).original); |
1167 | 0 | } |
1168 | | |
1169 | | // No conflicts means we're finished. Further checks are all RBF-only. |
1170 | 0 | if (!m_subpackage.m_rbf) return true; Branch (1170:9): [True: 0, False: 0]
|
1171 | | |
1172 | | // We're in package RBF context; replacement proposal must be size 2 |
1173 | 0 | if (workspaces.size() != 2 || !Assume(IsChildWithParents(txns))) { Branch (1173:9): [True: 0, False: 0]
Branch (1173:9): [True: 0, False: 0]
Branch (1173:35): [True: 0, False: 0]
|
1174 | 0 | return package_state.Invalid(PackageValidationResult::PCKG_POLICY, "package RBF failed: package must be 1-parent-1-child"); |
1175 | 0 | } |
1176 | | |
1177 | | // If the package has in-mempool ancestors, we won't consider a package RBF |
1178 | | // since it would result in a cluster larger than 2. |
1179 | | // N.B. To relax this constraint we will need to revisit how CCoinsViewMemPool::PackageAddTransaction |
1180 | | // is being used inside AcceptMultipleTransactions to track available inputs while processing a package. |
1181 | 0 | for (const auto& ws : workspaces) { Branch (1181:25): [True: 0, False: 0]
|
1182 | 0 | if (!ws.m_ancestors.empty()) { Branch (1182:13): [True: 0, False: 0]
|
1183 | 0 | return package_state.Invalid(PackageValidationResult::PCKG_POLICY, "package RBF failed: new transaction cannot have mempool ancestors"); |
1184 | 0 | } |
1185 | 0 | } |
1186 | | |
1187 | | // Aggregate all conflicts into one set. |
1188 | 0 | CTxMemPool::setEntries direct_conflict_iters; |
1189 | 0 | for (Workspace& ws : workspaces) { Branch (1189:24): [True: 0, False: 0]
|
1190 | | // Aggregate all conflicts into one set. |
1191 | 0 | direct_conflict_iters.merge(ws.m_iters_conflicting); |
1192 | 0 | } |
1193 | |
|
1194 | 0 | const auto& parent_ws = workspaces[0]; |
1195 | 0 | const auto& child_ws = workspaces[1]; |
1196 | | |
1197 | | // Don't consider replacements that would cause us to remove a large number of mempool entries. |
1198 | | // This limit is not increased in a package RBF. Use the aggregate number of transactions. |
1199 | 0 | if (const auto err_string{GetEntriesForConflicts(*child_ws.m_ptx, m_pool, direct_conflict_iters, Branch (1199:20): [True: 0, False: 0]
|
1200 | 0 | m_subpackage.m_all_conflicts)}) { |
1201 | 0 | return package_state.Invalid(PackageValidationResult::PCKG_POLICY, |
1202 | 0 | "package RBF failed: too many potential replacements", *err_string); |
1203 | 0 | } |
1204 | | |
1205 | 0 | for (CTxMemPool::txiter it : m_subpackage.m_all_conflicts) { Branch (1205:32): [True: 0, False: 0]
|
1206 | 0 | m_subpackage.m_conflicting_fees += it->GetModifiedFee(); |
1207 | 0 | m_subpackage.m_conflicting_size += it->GetTxSize(); |
1208 | 0 | } |
1209 | | |
1210 | | // Use the child as the transaction for attributing errors to. |
1211 | 0 | const Txid& child_hash = child_ws.m_ptx->GetHash(); |
1212 | 0 | if (const auto err_string{PaysForRBF(/*original_fees=*/m_subpackage.m_conflicting_fees, Branch (1212:20): [True: 0, False: 0]
|
1213 | 0 | /*replacement_fees=*/m_subpackage.m_total_modified_fees, |
1214 | 0 | /*replacement_vsize=*/m_subpackage.m_total_vsize, |
1215 | 0 | m_pool.m_opts.incremental_relay_feerate, child_hash)}) { |
1216 | 0 | return package_state.Invalid(PackageValidationResult::PCKG_POLICY, |
1217 | 0 | "package RBF failed: insufficient anti-DoS fees", *err_string); |
1218 | 0 | } |
1219 | | |
1220 | | // Ensure this two transaction package is a "chunk" on its own; we don't want the child |
1221 | | // to be only paying anti-DoS fees |
1222 | 0 | const CFeeRate parent_feerate(parent_ws.m_modified_fees, parent_ws.m_vsize); |
1223 | 0 | const CFeeRate package_feerate(m_subpackage.m_total_modified_fees, m_subpackage.m_total_vsize); |
1224 | 0 | if (package_feerate <= parent_feerate) { Branch (1224:9): [True: 0, False: 0]
|
1225 | 0 | return package_state.Invalid(PackageValidationResult::PCKG_POLICY, |
1226 | 0 | "package RBF failed: package feerate is less than or equal to parent feerate", |
1227 | 0 | strprintf("package feerate %s <= parent feerate is %s", package_feerate.ToString(), parent_feerate.ToString())); |
1228 | 0 | } |
1229 | | |
1230 | | // Check if it's economically rational to mine this package rather than the ones it replaces. |
1231 | | // This takes the place of ReplacementChecks()'s PaysMoreThanConflicts() in the package RBF setting. |
1232 | 0 | if (const auto err_tup{ImprovesFeerateDiagram(m_pool, direct_conflict_iters, m_subpackage.m_all_conflicts, m_subpackage.m_total_modified_fees, m_subpackage.m_total_vsize)}) { Branch (1232:20): [True: 0, False: 0]
|
1233 | 0 | return package_state.Invalid(PackageValidationResult::PCKG_POLICY, |
1234 | 0 | "package RBF failed: " + err_tup.value().second, ""); |
1235 | 0 | } |
1236 | | |
1237 | 0 | LogPrint(BCLog::TXPACKAGES, "package RBF checks passed: parent %s (wtxid=%s), child %s (wtxid=%s)\n", |
1238 | 0 | txns.front()->GetHash().ToString(), txns.front()->GetWitnessHash().ToString(), |
1239 | 0 | txns.back()->GetHash().ToString(), txns.back()->GetWitnessHash().ToString()); |
1240 | | |
1241 | |
|
1242 | 0 | return true; |
1243 | 0 | } |
1244 | | |
1245 | | bool MemPoolAccept::PolicyScriptChecks(const ATMPArgs& args, Workspace& ws) |
1246 | 0 | { |
1247 | 0 | AssertLockHeld(cs_main); |
1248 | 0 | AssertLockHeld(m_pool.cs); |
1249 | 0 | const CTransaction& tx = *ws.m_ptx; |
1250 | 0 | TxValidationState& state = ws.m_state; |
1251 | |
|
1252 | 0 | constexpr unsigned int scriptVerifyFlags = STANDARD_SCRIPT_VERIFY_FLAGS; |
1253 | | |
1254 | | // Check input scripts and signatures. |
1255 | | // This is done last to help prevent CPU exhaustion denial-of-service attacks. |
1256 | 0 | if (!CheckInputScripts(tx, state, m_view, scriptVerifyFlags, true, false, ws.m_precomputed_txdata, GetValidationCache())) { Branch (1256:9): [True: 0, False: 0]
|
1257 | | // SCRIPT_VERIFY_CLEANSTACK requires SCRIPT_VERIFY_WITNESS, so we |
1258 | | // need to turn both off, and compare against just turning off CLEANSTACK |
1259 | | // to see if the failure is specifically due to witness validation. |
1260 | 0 | TxValidationState state_dummy; // Want reported failures to be from first CheckInputScripts |
1261 | 0 | if (!tx.HasWitness() && CheckInputScripts(tx, state_dummy, m_view, scriptVerifyFlags & ~(SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_CLEANSTACK), true, false, ws.m_precomputed_txdata, GetValidationCache()) && Branch (1261:13): [True: 0, False: 0]
Branch (1261:33): [True: 0, False: 0]
|
1262 | 0 | !CheckInputScripts(tx, state_dummy, m_view, scriptVerifyFlags & ~SCRIPT_VERIFY_CLEANSTACK, true, false, ws.m_precomputed_txdata, GetValidationCache())) { Branch (1262:17): [True: 0, False: 0]
|
1263 | | // Only the witness is missing, so the transaction itself may be fine. |
1264 | 0 | state.Invalid(TxValidationResult::TX_WITNESS_STRIPPED, |
1265 | 0 | state.GetRejectReason(), state.GetDebugMessage()); |
1266 | 0 | } |
1267 | 0 | return false; // state filled in by CheckInputScripts |
1268 | 0 | } |
1269 | | |
1270 | 0 | return true; |
1271 | 0 | } |
1272 | | |
1273 | | bool MemPoolAccept::ConsensusScriptChecks(const ATMPArgs& args, Workspace& ws) |
1274 | 0 | { |
1275 | 0 | AssertLockHeld(cs_main); |
1276 | 0 | AssertLockHeld(m_pool.cs); |
1277 | 0 | const CTransaction& tx = *ws.m_ptx; |
1278 | 0 | const uint256& hash = ws.m_hash; |
1279 | 0 | TxValidationState& state = ws.m_state; |
1280 | | |
1281 | | // Check again against the current block tip's script verification |
1282 | | // flags to cache our script execution flags. This is, of course, |
1283 | | // useless if the next block has different script flags from the |
1284 | | // previous one, but because the cache tracks script flags for us it |
1285 | | // will auto-invalidate and we'll just have a few blocks of extra |
1286 | | // misses on soft-fork activation. |
1287 | | // |
1288 | | // This is also useful in case of bugs in the standard flags that cause |
1289 | | // transactions to pass as valid when they're actually invalid. For |
1290 | | // instance the STRICTENC flag was incorrectly allowing certain |
1291 | | // CHECKSIG NOT scripts to pass, even though they were invalid. |
1292 | | // |
1293 | | // There is a similar check in CreateNewBlock() to prevent creating |
1294 | | // invalid blocks (using TestBlockValidity), however allowing such |
1295 | | // transactions into the mempool can be exploited as a DoS attack. |
1296 | 0 | unsigned int currentBlockScriptVerifyFlags{GetBlockScriptFlags(*m_active_chainstate.m_chain.Tip(), m_active_chainstate.m_chainman)}; |
1297 | 0 | if (!CheckInputsFromMempoolAndCache(tx, state, m_view, m_pool, currentBlockScriptVerifyFlags, Branch (1297:9): [True: 0, False: 0]
|
1298 | 0 | ws.m_precomputed_txdata, m_active_chainstate.CoinsTip(), GetValidationCache())) { |
1299 | 0 | LogPrintf("BUG! PLEASE REPORT THIS! CheckInputScripts failed against latest-block but not STANDARD flags %s, %s\n", hash.ToString(), state.ToString()); |
1300 | 0 | return Assume(false); |
1301 | 0 | } |
1302 | | |
1303 | 0 | return true; |
1304 | 0 | } |
1305 | | |
1306 | | bool MemPoolAccept::Finalize(const ATMPArgs& args, Workspace& ws) |
1307 | 0 | { |
1308 | 0 | AssertLockHeld(cs_main); |
1309 | 0 | AssertLockHeld(m_pool.cs); |
1310 | 0 | const CTransaction& tx = *ws.m_ptx; |
1311 | 0 | const uint256& hash = ws.m_hash; |
1312 | 0 | TxValidationState& state = ws.m_state; |
1313 | 0 | const bool bypass_limits = args.m_bypass_limits; |
1314 | 0 | std::unique_ptr<CTxMemPoolEntry>& entry = ws.m_entry; |
1315 | |
|
1316 | 0 | if (!m_subpackage.m_all_conflicts.empty()) Assume(args.m_allow_replacement); Branch (1316:9): [True: 0, False: 0]
|
1317 | | // Remove conflicting transactions from the mempool |
1318 | 0 | for (CTxMemPool::txiter it : m_subpackage.m_all_conflicts) Branch (1318:32): [True: 0, False: 0]
|
1319 | 0 | { |
1320 | 0 | LogPrint(BCLog::MEMPOOL, "replacing mempool tx %s (wtxid=%s, fees=%s, vsize=%s). New tx %s (wtxid=%s, fees=%s, vsize=%s)\n", |
1321 | 0 | it->GetTx().GetHash().ToString(), |
1322 | 0 | it->GetTx().GetWitnessHash().ToString(), |
1323 | 0 | it->GetFee(), |
1324 | 0 | it->GetTxSize(), |
1325 | 0 | hash.ToString(), |
1326 | 0 | tx.GetWitnessHash().ToString(), |
1327 | 0 | entry->GetFee(), |
1328 | 0 | entry->GetTxSize()); |
1329 | 0 | TRACE7(mempool, replaced, |
1330 | 0 | it->GetTx().GetHash().data(), |
1331 | 0 | it->GetTxSize(), |
1332 | 0 | it->GetFee(), |
1333 | 0 | std::chrono::duration_cast<std::chrono::duration<std::uint64_t>>(it->GetTime()).count(), |
1334 | 0 | hash.data(), |
1335 | 0 | entry->GetTxSize(), |
1336 | 0 | entry->GetFee() |
1337 | 0 | ); |
1338 | 0 | m_subpackage.m_replaced_transactions.push_back(it->GetSharedTx()); |
1339 | 0 | } |
1340 | 0 | m_pool.RemoveStaged(m_subpackage.m_all_conflicts, false, MemPoolRemovalReason::REPLACED); |
1341 | | // Don't attempt to process the same conflicts repeatedly during subpackage evaluation: |
1342 | | // they no longer exist on subsequent calls to Finalize() post-RemoveStaged |
1343 | 0 | m_subpackage.m_all_conflicts.clear(); |
1344 | | // Store transaction in memory |
1345 | 0 | m_pool.addUnchecked(*entry, ws.m_ancestors); |
1346 | | |
1347 | | // trim mempool and check if tx was trimmed |
1348 | | // If we are validating a package, don't trim here because we could evict a previous transaction |
1349 | | // in the package. LimitMempoolSize() should be called at the very end to make sure the mempool |
1350 | | // is still within limits and package submission happens atomically. |
1351 | 0 | if (!args.m_package_submission && !bypass_limits) { Branch (1351:9): [True: 0, False: 0]
Branch (1351:39): [True: 0, False: 0]
|
1352 | 0 | LimitMempoolSize(m_pool, m_active_chainstate.CoinsTip()); |
1353 | 0 | if (!m_pool.exists(GenTxid::Txid(hash))) Branch (1353:13): [True: 0, False: 0]
|
1354 | | // The tx no longer meets our (new) mempool minimum feerate but could be reconsidered in a package. |
1355 | 0 | return state.Invalid(TxValidationResult::TX_RECONSIDERABLE, "mempool full"); |
1356 | 0 | } |
1357 | 0 | return true; |
1358 | 0 | } |
1359 | | |
1360 | | bool MemPoolAccept::SubmitPackage(const ATMPArgs& args, std::vector<Workspace>& workspaces, |
1361 | | PackageValidationState& package_state, |
1362 | | std::map<uint256, MempoolAcceptResult>& results) |
1363 | 0 | { |
1364 | 0 | AssertLockHeld(cs_main); |
1365 | 0 | AssertLockHeld(m_pool.cs); |
1366 | | // Sanity check: none of the transactions should be in the mempool, and none of the transactions |
1367 | | // should have a same-txid-different-witness equivalent in the mempool. |
1368 | 0 | assert(std::all_of(workspaces.cbegin(), workspaces.cend(), [this](const auto& ws){ |
1369 | 0 | return !m_pool.exists(GenTxid::Txid(ws.m_ptx->GetHash())); })); |
1370 | | |
1371 | 0 | bool all_submitted = true; |
1372 | | // ConsensusScriptChecks adds to the script cache and is therefore consensus-critical; |
1373 | | // CheckInputsFromMempoolAndCache asserts that transactions only spend coins available from the |
1374 | | // mempool or UTXO set. Submit each transaction to the mempool immediately after calling |
1375 | | // ConsensusScriptChecks to make the outputs available for subsequent transactions. |
1376 | 0 | for (Workspace& ws : workspaces) { Branch (1376:24): [True: 0, False: 0]
|
1377 | 0 | if (!ConsensusScriptChecks(args, ws)) { Branch (1377:13): [True: 0, False: 0]
|
1378 | 0 | results.emplace(ws.m_ptx->GetWitnessHash(), MempoolAcceptResult::Failure(ws.m_state)); |
1379 | | // Since PolicyScriptChecks() passed, this should never fail. |
1380 | 0 | Assume(false); |
1381 | 0 | all_submitted = false; |
1382 | 0 | package_state.Invalid(PackageValidationResult::PCKG_MEMPOOL_ERROR, |
1383 | 0 | strprintf("BUG! PolicyScriptChecks succeeded but ConsensusScriptChecks failed: %s", |
1384 | 0 | ws.m_ptx->GetHash().ToString())); |
1385 | 0 | } |
1386 | | |
1387 | | // Re-calculate mempool ancestors to call addUnchecked(). They may have changed since the |
1388 | | // last calculation done in PreChecks, since package ancestors have already been submitted. |
1389 | 0 | { |
1390 | 0 | auto ancestors{m_pool.CalculateMemPoolAncestors(*ws.m_entry, m_pool.m_opts.limits)}; |
1391 | 0 | if(!ancestors) { Branch (1391:16): [True: 0, False: 0]
|
1392 | 0 | results.emplace(ws.m_ptx->GetWitnessHash(), MempoolAcceptResult::Failure(ws.m_state)); |
1393 | | // Since PreChecks() and PackageMempoolChecks() both enforce limits, this should never fail. |
1394 | 0 | Assume(false); |
1395 | 0 | all_submitted = false; |
1396 | 0 | package_state.Invalid(PackageValidationResult::PCKG_MEMPOOL_ERROR, |
1397 | 0 | strprintf("BUG! Mempool ancestors or descendants were underestimated: %s", |
1398 | 0 | ws.m_ptx->GetHash().ToString())); |
1399 | 0 | } |
1400 | 0 | ws.m_ancestors = std::move(ancestors).value_or(ws.m_ancestors); |
1401 | 0 | } |
1402 | | // If we call LimitMempoolSize() for each individual Finalize(), the mempool will not take |
1403 | | // the transaction's descendant feerate into account because it hasn't seen them yet. Also, |
1404 | | // we risk evicting a transaction that a subsequent package transaction depends on. Instead, |
1405 | | // allow the mempool to temporarily bypass limits, the maximum package size) while |
1406 | | // submitting transactions individually and then trim at the very end. |
1407 | 0 | if (!Finalize(args, ws)) { Branch (1407:13): [True: 0, False: 0]
|
1408 | 0 | results.emplace(ws.m_ptx->GetWitnessHash(), MempoolAcceptResult::Failure(ws.m_state)); |
1409 | | // Since LimitMempoolSize() won't be called, this should never fail. |
1410 | 0 | Assume(false); |
1411 | 0 | all_submitted = false; |
1412 | 0 | package_state.Invalid(PackageValidationResult::PCKG_MEMPOOL_ERROR, |
1413 | 0 | strprintf("BUG! Adding to mempool failed: %s", ws.m_ptx->GetHash().ToString())); |
1414 | 0 | } |
1415 | 0 | } |
1416 | |
|
1417 | 0 | std::vector<Wtxid> all_package_wtxids; |
1418 | 0 | all_package_wtxids.reserve(workspaces.size()); |
1419 | 0 | std::transform(workspaces.cbegin(), workspaces.cend(), std::back_inserter(all_package_wtxids), |
1420 | 0 | [](const auto& ws) { return ws.m_ptx->GetWitnessHash(); }); |
1421 | |
|
1422 | 0 | if (!m_subpackage.m_replaced_transactions.empty()) { Branch (1422:9): [True: 0, False: 0]
|
1423 | 0 | LogPrint(BCLog::MEMPOOL, "replaced %u mempool transactions with %u new one(s) for %s additional fees, %d delta bytes\n", |
1424 | 0 | m_subpackage.m_replaced_transactions.size(), workspaces.size(), |
1425 | 0 | m_subpackage.m_total_modified_fees - m_subpackage.m_conflicting_fees, |
1426 | 0 | m_subpackage.m_total_vsize - static_cast<int>(m_subpackage.m_conflicting_size)); |
1427 | 0 | } |
1428 | | |
1429 | | // Add successful results. The returned results may change later if LimitMempoolSize() evicts them. |
1430 | 0 | for (Workspace& ws : workspaces) { Branch (1430:24): [True: 0, False: 0]
|
1431 | 0 | const auto effective_feerate = args.m_package_feerates ? ws.m_package_feerate : Branch (1431:40): [True: 0, False: 0]
|
1432 | 0 | CFeeRate{ws.m_modified_fees, static_cast<uint32_t>(ws.m_vsize)}; |
1433 | 0 | const auto effective_feerate_wtxids = args.m_package_feerates ? all_package_wtxids : Branch (1433:47): [True: 0, False: 0]
|
1434 | 0 | std::vector<Wtxid>{ws.m_ptx->GetWitnessHash()}; |
1435 | 0 | results.emplace(ws.m_ptx->GetWitnessHash(), |
1436 | 0 | MempoolAcceptResult::Success(std::move(m_subpackage.m_replaced_transactions), ws.m_vsize, |
1437 | 0 | ws.m_base_fees, effective_feerate, effective_feerate_wtxids)); |
1438 | 0 | if (!m_pool.m_opts.signals) continue; Branch (1438:13): [True: 0, False: 0]
|
1439 | 0 | const CTransaction& tx = *ws.m_ptx; |
1440 | 0 | const auto tx_info = NewMempoolTransactionInfo(ws.m_ptx, ws.m_base_fees, |
1441 | 0 | ws.m_vsize, ws.m_entry->GetHeight(), |
1442 | 0 | args.m_bypass_limits, args.m_package_submission, |
1443 | 0 | IsCurrentForFeeEstimation(m_active_chainstate), |
1444 | 0 | m_pool.HasNoInputsOf(tx)); |
1445 | 0 | m_pool.m_opts.signals->TransactionAddedToMempool(tx_info, m_pool.GetAndIncrementSequence()); |
1446 | 0 | } |
1447 | 0 | return all_submitted; |
1448 | 0 | } |
1449 | | |
1450 | | MempoolAcceptResult MemPoolAccept::AcceptSingleTransaction(const CTransactionRef& ptx, ATMPArgs& args) |
1451 | 0 | { |
1452 | 0 | AssertLockHeld(cs_main); |
1453 | 0 | LOCK(m_pool.cs); // mempool "read lock" (held through m_pool.m_opts.signals->TransactionAddedToMempool()) |
1454 | |
|
1455 | 0 | Workspace ws(ptx); |
1456 | 0 | const std::vector<Wtxid> single_wtxid{ws.m_ptx->GetWitnessHash()}; |
1457 | |
|
1458 | 0 | if (!PreChecks(args, ws)) { Branch (1458:9): [True: 0, False: 0]
|
1459 | 0 | if (ws.m_state.GetResult() == TxValidationResult::TX_RECONSIDERABLE) { Branch (1459:13): [True: 0, False: 0]
|
1460 | | // Failed for fee reasons. Provide the effective feerate and which tx was included. |
1461 | 0 | return MempoolAcceptResult::FeeFailure(ws.m_state, CFeeRate(ws.m_modified_fees, ws.m_vsize), single_wtxid); |
1462 | 0 | } |
1463 | 0 | return MempoolAcceptResult::Failure(ws.m_state); |
1464 | 0 | } |
1465 | | |
1466 | | // Individual modified feerate exceeded caller-defined max; abort |
1467 | 0 | if (args.m_client_maxfeerate && CFeeRate(ws.m_modified_fees, ws.m_vsize) > args.m_client_maxfeerate.value()) { Branch (1467:9): [True: 0, False: 0]
Branch (1467:9): [True: 0, False: 0]
Branch (1467:37): [True: 0, False: 0]
|
1468 | 0 | ws.m_state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "max feerate exceeded", ""); |
1469 | 0 | return MempoolAcceptResult::Failure(ws.m_state); |
1470 | 0 | } |
1471 | | |
1472 | 0 | if (m_subpackage.m_rbf && !ReplacementChecks(ws)) { Branch (1472:9): [True: 0, False: 0]
Branch (1472:31): [True: 0, False: 0]
|
1473 | 0 | if (ws.m_state.GetResult() == TxValidationResult::TX_RECONSIDERABLE) { Branch (1473:13): [True: 0, False: 0]
|
1474 | | // Failed for incentives-based fee reasons. Provide the effective feerate and which tx was included. |
1475 | 0 | return MempoolAcceptResult::FeeFailure(ws.m_state, CFeeRate(ws.m_modified_fees, ws.m_vsize), single_wtxid); |
1476 | 0 | } |
1477 | 0 | return MempoolAcceptResult::Failure(ws.m_state); |
1478 | 0 | } |
1479 | | |
1480 | | // Perform the inexpensive checks first and avoid hashing and signature verification unless |
1481 | | // those checks pass, to mitigate CPU exhaustion denial-of-service attacks. |
1482 | 0 | if (!PolicyScriptChecks(args, ws)) return MempoolAcceptResult::Failure(ws.m_state); Branch (1482:9): [True: 0, False: 0]
|
1483 | | |
1484 | 0 | if (!ConsensusScriptChecks(args, ws)) return MempoolAcceptResult::Failure(ws.m_state); Branch (1484:9): [True: 0, False: 0]
|
1485 | | |
1486 | 0 | const CFeeRate effective_feerate{ws.m_modified_fees, static_cast<uint32_t>(ws.m_vsize)}; |
1487 | | // Tx was accepted, but not added |
1488 | 0 | if (args.m_test_accept) { Branch (1488:9): [True: 0, False: 0]
|
1489 | 0 | return MempoolAcceptResult::Success(std::move(m_subpackage.m_replaced_transactions), ws.m_vsize, |
1490 | 0 | ws.m_base_fees, effective_feerate, single_wtxid); |
1491 | 0 | } |
1492 | | |
1493 | 0 | if (!Finalize(args, ws)) { Branch (1493:9): [True: 0, False: 0]
|
1494 | | // The only possible failure reason is fee-related (mempool full). |
1495 | | // Failed for fee reasons. Provide the effective feerate and which txns were included. |
1496 | 0 | Assume(ws.m_state.GetResult() == TxValidationResult::TX_RECONSIDERABLE); |
1497 | 0 | return MempoolAcceptResult::FeeFailure(ws.m_state, CFeeRate(ws.m_modified_fees, ws.m_vsize), {ws.m_ptx->GetWitnessHash()}); |
1498 | 0 | } |
1499 | | |
1500 | 0 | if (m_pool.m_opts.signals) { Branch (1500:9): [True: 0, False: 0]
|
1501 | 0 | const CTransaction& tx = *ws.m_ptx; |
1502 | 0 | const auto tx_info = NewMempoolTransactionInfo(ws.m_ptx, ws.m_base_fees, |
1503 | 0 | ws.m_vsize, ws.m_entry->GetHeight(), |
1504 | 0 | args.m_bypass_limits, args.m_package_submission, |
1505 | 0 | IsCurrentForFeeEstimation(m_active_chainstate), |
1506 | 0 | m_pool.HasNoInputsOf(tx)); |
1507 | 0 | m_pool.m_opts.signals->TransactionAddedToMempool(tx_info, m_pool.GetAndIncrementSequence()); |
1508 | 0 | } |
1509 | |
|
1510 | 0 | if (!m_subpackage.m_replaced_transactions.empty()) { Branch (1510:9): [True: 0, False: 0]
|
1511 | 0 | LogPrint(BCLog::MEMPOOL, "replaced %u mempool transactions with 1 new transaction for %s additional fees, %d delta bytes\n", |
1512 | 0 | m_subpackage.m_replaced_transactions.size(), |
1513 | 0 | ws.m_modified_fees - m_subpackage.m_conflicting_fees, |
1514 | 0 | ws.m_vsize - static_cast<int>(m_subpackage.m_conflicting_size)); |
1515 | 0 | } |
1516 | |
|
1517 | 0 | return MempoolAcceptResult::Success(std::move(m_subpackage.m_replaced_transactions), ws.m_vsize, ws.m_base_fees, |
1518 | 0 | effective_feerate, single_wtxid); |
1519 | 0 | } |
1520 | | |
1521 | | PackageMempoolAcceptResult MemPoolAccept::AcceptMultipleTransactions(const std::vector<CTransactionRef>& txns, ATMPArgs& args) |
1522 | 0 | { |
1523 | 0 | AssertLockHeld(cs_main); |
1524 | | |
1525 | | // These context-free package limits can be done before taking the mempool lock. |
1526 | 0 | PackageValidationState package_state; |
1527 | 0 | if (!IsWellFormedPackage(txns, package_state, /*require_sorted=*/true)) return PackageMempoolAcceptResult(package_state, {}); Branch (1527:9): [True: 0, False: 0]
|
1528 | | |
1529 | 0 | std::vector<Workspace> workspaces{}; |
1530 | 0 | workspaces.reserve(txns.size()); |
1531 | 0 | std::transform(txns.cbegin(), txns.cend(), std::back_inserter(workspaces), |
1532 | 0 | [](const auto& tx) { return Workspace(tx); }); |
1533 | 0 | std::map<uint256, MempoolAcceptResult> results; |
1534 | |
|
1535 | 0 | LOCK(m_pool.cs); |
1536 | | |
1537 | | // Do all PreChecks first and fail fast to avoid running expensive script checks when unnecessary. |
1538 | 0 | for (Workspace& ws : workspaces) { Branch (1538:24): [True: 0, False: 0]
|
1539 | 0 | if (!PreChecks(args, ws)) { Branch (1539:13): [True: 0, False: 0]
|
1540 | 0 | package_state.Invalid(PackageValidationResult::PCKG_TX, "transaction failed"); |
1541 | | // Exit early to avoid doing pointless work. Update the failed tx result; the rest are unfinished. |
1542 | 0 | results.emplace(ws.m_ptx->GetWitnessHash(), MempoolAcceptResult::Failure(ws.m_state)); |
1543 | 0 | return PackageMempoolAcceptResult(package_state, std::move(results)); |
1544 | 0 | } |
1545 | | |
1546 | | // Individual modified feerate exceeded caller-defined max; abort |
1547 | | // N.B. this doesn't take into account CPFPs. Chunk-aware validation may be more robust. |
1548 | 0 | if (args.m_client_maxfeerate && CFeeRate(ws.m_modified_fees, ws.m_vsize) > args.m_client_maxfeerate.value()) { Branch (1548:13): [True: 0, False: 0]
Branch (1548:13): [True: 0, False: 0]
Branch (1548:41): [True: 0, False: 0]
|
1549 | | // Need to set failure here both individually and at package level |
1550 | 0 | ws.m_state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "max feerate exceeded", ""); |
1551 | 0 | package_state.Invalid(PackageValidationResult::PCKG_TX, "transaction failed"); |
1552 | | // Exit early to avoid doing pointless work. Update the failed tx result; the rest are unfinished. |
1553 | 0 | results.emplace(ws.m_ptx->GetWitnessHash(), MempoolAcceptResult::Failure(ws.m_state)); |
1554 | 0 | return PackageMempoolAcceptResult(package_state, std::move(results)); |
1555 | 0 | } |
1556 | | |
1557 | | // Make the coins created by this transaction available for subsequent transactions in the |
1558 | | // package to spend. If there are no conflicts within the package, no transaction can spend a coin |
1559 | | // needed by another transaction in the package. We also need to make sure that no package |
1560 | | // tx replaces (or replaces the ancestor of) the parent of another package tx. As long as we |
1561 | | // check these two things, we don't need to track the coins spent. |
1562 | | // If a package tx conflicts with a mempool tx, PackageMempoolChecks() ensures later that any package RBF attempt |
1563 | | // has *no* in-mempool ancestors, so we don't have to worry about subsequent transactions in |
1564 | | // same package spending the same in-mempool outpoints. This needs to be revisited for general |
1565 | | // package RBF. |
1566 | 0 | m_viewmempool.PackageAddTransaction(ws.m_ptx); |
1567 | 0 | } |
1568 | | |
1569 | | // At this point we have all in-mempool ancestors, and we know every transaction's vsize. |
1570 | | // Run the TRUC checks on the package. |
1571 | 0 | for (Workspace& ws : workspaces) { Branch (1571:24): [True: 0, False: 0]
|
1572 | 0 | if (auto err{PackageTRUCChecks(ws.m_ptx, ws.m_vsize, txns, ws.m_ancestors)}) { Branch (1572:18): [True: 0, False: 0]
|
1573 | 0 | package_state.Invalid(PackageValidationResult::PCKG_POLICY, "TRUC-violation", err.value()); |
1574 | 0 | return PackageMempoolAcceptResult(package_state, {}); |
1575 | 0 | } |
1576 | 0 | } |
1577 | | |
1578 | | // Transactions must meet two minimum feerates: the mempool minimum fee and min relay fee. |
1579 | | // For transactions consisting of exactly one child and its parents, it suffices to use the |
1580 | | // package feerate (total modified fees / total virtual size) to check this requirement. |
1581 | | // Note that this is an aggregate feerate; this function has not checked that there are transactions |
1582 | | // too low feerate to pay for themselves, or that the child transactions are higher feerate than |
1583 | | // their parents. Using aggregate feerate may allow "parents pay for child" behavior and permit |
1584 | | // a child that is below mempool minimum feerate. To avoid these behaviors, callers of |
1585 | | // AcceptMultipleTransactions need to restrict txns topology (e.g. to ancestor sets) and check |
1586 | | // the feerates of individuals and subsets. |
1587 | 0 | m_subpackage.m_total_vsize = std::accumulate(workspaces.cbegin(), workspaces.cend(), int64_t{0}, |
1588 | 0 | [](int64_t sum, auto& ws) { return sum + ws.m_vsize; }); |
1589 | 0 | m_subpackage.m_total_modified_fees = std::accumulate(workspaces.cbegin(), workspaces.cend(), CAmount{0}, |
1590 | 0 | [](CAmount sum, auto& ws) { return sum + ws.m_modified_fees; }); |
1591 | 0 | const CFeeRate package_feerate(m_subpackage.m_total_modified_fees, m_subpackage.m_total_vsize); |
1592 | 0 | std::vector<Wtxid> all_package_wtxids; |
1593 | 0 | all_package_wtxids.reserve(workspaces.size()); |
1594 | 0 | std::transform(workspaces.cbegin(), workspaces.cend(), std::back_inserter(all_package_wtxids), |
1595 | 0 | [](const auto& ws) { return ws.m_ptx->GetWitnessHash(); }); |
1596 | 0 | TxValidationState placeholder_state; |
1597 | 0 | if (args.m_package_feerates && Branch (1597:9): [True: 0, False: 0]
|
1598 | 0 | !CheckFeeRate(m_subpackage.m_total_vsize, m_subpackage.m_total_modified_fees, placeholder_state)) { Branch (1598:9): [True: 0, False: 0]
|
1599 | 0 | package_state.Invalid(PackageValidationResult::PCKG_TX, "transaction failed"); |
1600 | 0 | return PackageMempoolAcceptResult(package_state, {{workspaces.back().m_ptx->GetWitnessHash(), |
1601 | 0 | MempoolAcceptResult::FeeFailure(placeholder_state, CFeeRate(m_subpackage.m_total_modified_fees, m_subpackage.m_total_vsize), all_package_wtxids)}}); |
1602 | 0 | } |
1603 | | |
1604 | | // Apply package mempool ancestor/descendant limits. Skip if there is only one transaction, |
1605 | | // because it's unnecessary. |
1606 | 0 | if (txns.size() > 1 && !PackageMempoolChecks(txns, workspaces, m_subpackage.m_total_vsize, package_state)) { Branch (1606:9): [True: 0, False: 0]
Branch (1606:28): [True: 0, False: 0]
|
1607 | 0 | return PackageMempoolAcceptResult(package_state, std::move(results)); |
1608 | 0 | } |
1609 | | |
1610 | 0 | for (Workspace& ws : workspaces) { Branch (1610:24): [True: 0, False: 0]
|
1611 | 0 | ws.m_package_feerate = package_feerate; |
1612 | 0 | if (!PolicyScriptChecks(args, ws)) { Branch (1612:13): [True: 0, False: 0]
|
1613 | | // Exit early to avoid doing pointless work. Update the failed tx result; the rest are unfinished. |
1614 | 0 | package_state.Invalid(PackageValidationResult::PCKG_TX, "transaction failed"); |
1615 | 0 | results.emplace(ws.m_ptx->GetWitnessHash(), MempoolAcceptResult::Failure(ws.m_state)); |
1616 | 0 | return PackageMempoolAcceptResult(package_state, std::move(results)); |
1617 | 0 | } |
1618 | 0 | if (args.m_test_accept) { Branch (1618:13): [True: 0, False: 0]
|
1619 | 0 | const auto effective_feerate = args.m_package_feerates ? ws.m_package_feerate : Branch (1619:44): [True: 0, False: 0]
|
1620 | 0 | CFeeRate{ws.m_modified_fees, static_cast<uint32_t>(ws.m_vsize)}; |
1621 | 0 | const auto effective_feerate_wtxids = args.m_package_feerates ? all_package_wtxids : Branch (1621:51): [True: 0, False: 0]
|
1622 | 0 | std::vector<Wtxid>{ws.m_ptx->GetWitnessHash()}; |
1623 | 0 | results.emplace(ws.m_ptx->GetWitnessHash(), |
1624 | 0 | MempoolAcceptResult::Success(std::move(m_subpackage.m_replaced_transactions), |
1625 | 0 | ws.m_vsize, ws.m_base_fees, effective_feerate, |
1626 | 0 | effective_feerate_wtxids)); |
1627 | 0 | } |
1628 | 0 | } |
1629 | | |
1630 | 0 | if (args.m_test_accept) return PackageMempoolAcceptResult(package_state, std::move(results)); Branch (1630:9): [True: 0, False: 0]
|
1631 | | |
1632 | 0 | if (!SubmitPackage(args, workspaces, package_state, results)) { Branch (1632:9): [True: 0, False: 0]
|
1633 | | // PackageValidationState filled in by SubmitPackage(). |
1634 | 0 | return PackageMempoolAcceptResult(package_state, std::move(results)); |
1635 | 0 | } |
1636 | | |
1637 | 0 | return PackageMempoolAcceptResult(package_state, std::move(results)); |
1638 | 0 | } |
1639 | | |
1640 | | void MemPoolAccept::CleanupTemporaryCoins() |
1641 | 0 | { |
1642 | | // There are 3 kinds of coins in m_view: |
1643 | | // (1) Temporary coins from the transactions in subpackage, constructed by m_viewmempool. |
1644 | | // (2) Mempool coins from transactions in the mempool, constructed by m_viewmempool. |
1645 | | // (3) Confirmed coins fetched from our current UTXO set. |
1646 | | // |
1647 | | // (1) Temporary coins need to be removed, regardless of whether the transaction was submitted. |
1648 | | // If the transaction was submitted to the mempool, m_viewmempool will be able to fetch them from |
1649 | | // there. If it wasn't submitted to mempool, it is incorrect to keep them - future calls may try |
1650 | | // to spend those coins that don't actually exist. |
1651 | | // (2) Mempool coins also need to be removed. If the mempool contents have changed as a result |
1652 | | // of submitting or replacing transactions, coins previously fetched from mempool may now be |
1653 | | // spent or nonexistent. Those coins need to be deleted from m_view. |
1654 | | // (3) Confirmed coins don't need to be removed. The chainstate has not changed (we are |
1655 | | // holding cs_main and no blocks have been processed) so the confirmed tx cannot disappear like |
1656 | | // a mempool tx can. The coin may now be spent after we submitted a tx to mempool, but |
1657 | | // we have already checked that the package does not have 2 transactions spending the same coin. |
1658 | | // Keeping them in m_view is an optimization to not re-fetch confirmed coins if we later look up |
1659 | | // inputs for this transaction again. |
1660 | 0 | for (const auto& outpoint : m_viewmempool.GetNonBaseCoins()) { Branch (1660:31): [True: 0, False: 0]
|
1661 | | // In addition to resetting m_viewmempool, we also need to manually delete these coins from |
1662 | | // m_view because it caches copies of the coins it fetched from m_viewmempool previously. |
1663 | 0 | m_view.Uncache(outpoint); |
1664 | 0 | } |
1665 | | // This deletes the temporary and mempool coins. |
1666 | 0 | m_viewmempool.Reset(); |
1667 | 0 | } |
1668 | | |
1669 | | PackageMempoolAcceptResult MemPoolAccept::AcceptSubPackage(const std::vector<CTransactionRef>& subpackage, ATMPArgs& args) |
1670 | 0 | { |
1671 | 0 | AssertLockHeld(::cs_main); |
1672 | 0 | AssertLockHeld(m_pool.cs); |
1673 | 0 | auto result = [&]() EXCLUSIVE_LOCKS_REQUIRED(::cs_main, m_pool.cs) { |
1674 | 0 | if (subpackage.size() > 1) { Branch (1674:13): [True: 0, False: 0]
|
1675 | 0 | return AcceptMultipleTransactions(subpackage, args); |
1676 | 0 | } |
1677 | 0 | const auto& tx = subpackage.front(); |
1678 | 0 | ATMPArgs single_args = ATMPArgs::SingleInPackageAccept(args); |
1679 | 0 | const auto single_res = AcceptSingleTransaction(tx, single_args); |
1680 | 0 | PackageValidationState package_state_wrapped; |
1681 | 0 | if (single_res.m_result_type != MempoolAcceptResult::ResultType::VALID) { Branch (1681:13): [True: 0, False: 0]
|
1682 | 0 | package_state_wrapped.Invalid(PackageValidationResult::PCKG_TX, "transaction failed"); |
1683 | 0 | } |
1684 | 0 | return PackageMempoolAcceptResult(package_state_wrapped, {{tx->GetWitnessHash(), single_res}}); |
1685 | 0 | }(); |
1686 | | |
1687 | | // Clean up m_view and m_viewmempool so that other subpackage evaluations don't have access to |
1688 | | // coins they shouldn't. Keep some coins in order to minimize re-fetching coins from the UTXO set. |
1689 | | // Clean up package feerate and rbf calculations |
1690 | 0 | ClearSubPackageState(); |
1691 | |
|
1692 | 0 | return result; |
1693 | 0 | } |
1694 | | |
1695 | | PackageMempoolAcceptResult MemPoolAccept::AcceptPackage(const Package& package, ATMPArgs& args) |
1696 | 0 | { |
1697 | 0 | AssertLockHeld(cs_main); |
1698 | | // Used if returning a PackageMempoolAcceptResult directly from this function. |
1699 | 0 | PackageValidationState package_state_quit_early; |
1700 | | |
1701 | | // Check that the package is well-formed. If it isn't, we won't try to validate any of the |
1702 | | // transactions and thus won't return any MempoolAcceptResults, just a package-wide error. |
1703 | | |
1704 | | // Context-free package checks. |
1705 | 0 | if (!IsWellFormedPackage(package, package_state_quit_early, /*require_sorted=*/true)) { Branch (1705:9): [True: 0, False: 0]
|
1706 | 0 | return PackageMempoolAcceptResult(package_state_quit_early, {}); |
1707 | 0 | } |
1708 | | |
1709 | | // All transactions in the package must be a parent of the last transaction. This is just an |
1710 | | // opportunity for us to fail fast on a context-free check without taking the mempool lock. |
1711 | 0 | if (!IsChildWithParents(package)) { Branch (1711:9): [True: 0, False: 0]
|
1712 | 0 | package_state_quit_early.Invalid(PackageValidationResult::PCKG_POLICY, "package-not-child-with-parents"); |
1713 | 0 | return PackageMempoolAcceptResult(package_state_quit_early, {}); |
1714 | 0 | } |
1715 | | |
1716 | | // IsChildWithParents() guarantees the package is > 1 transactions. |
1717 | 0 | assert(package.size() > 1); |
1718 | | // The package must be 1 child with all of its unconfirmed parents. The package is expected to |
1719 | | // be sorted, so the last transaction is the child. |
1720 | 0 | const auto& child = package.back(); |
1721 | 0 | std::unordered_set<uint256, SaltedTxidHasher> unconfirmed_parent_txids; |
1722 | 0 | std::transform(package.cbegin(), package.cend() - 1, |
1723 | 0 | std::inserter(unconfirmed_parent_txids, unconfirmed_parent_txids.end()), |
1724 | 0 | [](const auto& tx) { return tx->GetHash(); }); |
1725 | | |
1726 | | // All child inputs must refer to a preceding package transaction or a confirmed UTXO. The only |
1727 | | // way to verify this is to look up the child's inputs in our current coins view (not including |
1728 | | // mempool), and enforce that all parents not present in the package be available at chain tip. |
1729 | | // Since this check can bring new coins into the coins cache, keep track of these coins and |
1730 | | // uncache them if we don't end up submitting this package to the mempool. |
1731 | 0 | const CCoinsViewCache& coins_tip_cache = m_active_chainstate.CoinsTip(); |
1732 | 0 | for (const auto& input : child->vin) { Branch (1732:28): [True: 0, False: 0]
|
1733 | 0 | if (!coins_tip_cache.HaveCoinInCache(input.prevout)) { Branch (1733:13): [True: 0, False: 0]
|
1734 | 0 | args.m_coins_to_uncache.push_back(input.prevout); |
1735 | 0 | } |
1736 | 0 | } |
1737 | | // Using the MemPoolAccept m_view cache allows us to look up these same coins faster later. |
1738 | | // This should be connecting directly to CoinsTip, not to m_viewmempool, because we specifically |
1739 | | // require inputs to be confirmed if they aren't in the package. |
1740 | 0 | m_view.SetBackend(m_active_chainstate.CoinsTip()); |
1741 | 0 | const auto package_or_confirmed = [this, &unconfirmed_parent_txids](const auto& input) { |
1742 | 0 | return unconfirmed_parent_txids.count(input.prevout.hash) > 0 || m_view.HaveCoin(input.prevout); Branch (1742:17): [True: 0, False: 0]
Branch (1742:75): [True: 0, False: 0]
|
1743 | 0 | }; |
1744 | 0 | if (!std::all_of(child->vin.cbegin(), child->vin.cend(), package_or_confirmed)) { Branch (1744:9): [True: 0, False: 0]
|
1745 | 0 | package_state_quit_early.Invalid(PackageValidationResult::PCKG_POLICY, "package-not-child-with-unconfirmed-parents"); |
1746 | 0 | return PackageMempoolAcceptResult(package_state_quit_early, {}); |
1747 | 0 | } |
1748 | | // Protect against bugs where we pull more inputs from disk that miss being added to |
1749 | | // coins_to_uncache. The backend will be connected again when needed in PreChecks. |
1750 | 0 | m_view.SetBackend(m_dummy); |
1751 | |
|
1752 | 0 | LOCK(m_pool.cs); |
1753 | | // Stores results from which we will create the returned PackageMempoolAcceptResult. |
1754 | | // A result may be changed if a mempool transaction is evicted later due to LimitMempoolSize(). |
1755 | 0 | std::map<uint256, MempoolAcceptResult> results_final; |
1756 | | // Results from individual validation which will be returned if no other result is available for |
1757 | | // this transaction. "Nonfinal" because if a transaction fails by itself but succeeds later |
1758 | | // (i.e. when evaluated with a fee-bumping child), the result in this map may be discarded. |
1759 | 0 | std::map<uint256, MempoolAcceptResult> individual_results_nonfinal; |
1760 | 0 | bool quit_early{false}; |
1761 | 0 | std::vector<CTransactionRef> txns_package_eval; |
1762 | 0 | for (const auto& tx : package) { Branch (1762:25): [True: 0, False: 0]
|
1763 | 0 | const auto& wtxid = tx->GetWitnessHash(); |
1764 | 0 | const auto& txid = tx->GetHash(); |
1765 | | // There are 3 possibilities: already in mempool, same-txid-diff-wtxid already in mempool, |
1766 | | // or not in mempool. An already confirmed tx is treated as one not in mempool, because all |
1767 | | // we know is that the inputs aren't available. |
1768 | 0 | if (m_pool.exists(GenTxid::Wtxid(wtxid))) { Branch (1768:13): [True: 0, False: 0]
|
1769 | | // Exact transaction already exists in the mempool. |
1770 | | // Node operators are free to set their mempool policies however they please, nodes may receive |
1771 | | // transactions in different orders, and malicious counterparties may try to take advantage of |
1772 | | // policy differences to pin or delay propagation of transactions. As such, it's possible for |
1773 | | // some package transaction(s) to already be in the mempool, and we don't want to reject the |
1774 | | // entire package in that case (as that could be a censorship vector). De-duplicate the |
1775 | | // transactions that are already in the mempool, and only call AcceptMultipleTransactions() with |
1776 | | // the new transactions. This ensures we don't double-count transaction counts and sizes when |
1777 | | // checking ancestor/descendant limits, or double-count transaction fees for fee-related policy. |
1778 | 0 | const auto& entry{*Assert(m_pool.GetEntry(txid))}; |
1779 | 0 | results_final.emplace(wtxid, MempoolAcceptResult::MempoolTx(entry.GetTxSize(), entry.GetFee())); |
1780 | 0 | } else if (m_pool.exists(GenTxid::Txid(txid))) { Branch (1780:20): [True: 0, False: 0]
|
1781 | | // Transaction with the same non-witness data but different witness (same txid, |
1782 | | // different wtxid) already exists in the mempool. |
1783 | | // |
1784 | | // We don't allow replacement transactions right now, so just swap the package |
1785 | | // transaction for the mempool one. Note that we are ignoring the validity of the |
1786 | | // package transaction passed in. |
1787 | | // TODO: allow witness replacement in packages. |
1788 | 0 | const auto& entry{*Assert(m_pool.GetEntry(txid))}; |
1789 | | // Provide the wtxid of the mempool tx so that the caller can look it up in the mempool. |
1790 | 0 | results_final.emplace(wtxid, MempoolAcceptResult::MempoolTxDifferentWitness(entry.GetTx().GetWitnessHash())); |
1791 | 0 | } else { |
1792 | | // Transaction does not already exist in the mempool. |
1793 | | // Try submitting the transaction on its own. |
1794 | 0 | const auto single_package_res = AcceptSubPackage({tx}, args); |
1795 | 0 | const auto& single_res = single_package_res.m_tx_results.at(wtxid); |
1796 | 0 | if (single_res.m_result_type == MempoolAcceptResult::ResultType::VALID) { Branch (1796:17): [True: 0, False: 0]
|
1797 | | // The transaction succeeded on its own and is now in the mempool. Don't include it |
1798 | | // in package validation, because its fees should only be "used" once. |
1799 | 0 | assert(m_pool.exists(GenTxid::Wtxid(wtxid))); |
1800 | 0 | results_final.emplace(wtxid, single_res); |
1801 | 0 | } else if (single_res.m_state.GetResult() != TxValidationResult::TX_RECONSIDERABLE && Branch (1801:24): [True: 0, False: 0]
|
1802 | 0 | single_res.m_state.GetResult() != TxValidationResult::TX_MISSING_INPUTS) { Branch (1802:24): [True: 0, False: 0]
|
1803 | | // Package validation policy only differs from individual policy in its evaluation |
1804 | | // of feerate. For example, if a transaction fails here due to violation of a |
1805 | | // consensus rule, the result will not change when it is submitted as part of a |
1806 | | // package. To minimize the amount of repeated work, unless the transaction fails |
1807 | | // due to feerate or missing inputs (its parent is a previous transaction in the |
1808 | | // package that failed due to feerate), don't run package validation. Note that this |
1809 | | // decision might not make sense if different types of packages are allowed in the |
1810 | | // future. Continue individually validating the rest of the transactions, because |
1811 | | // some of them may still be valid. |
1812 | 0 | quit_early = true; |
1813 | 0 | package_state_quit_early.Invalid(PackageValidationResult::PCKG_TX, "transaction failed"); |
1814 | 0 | individual_results_nonfinal.emplace(wtxid, single_res); |
1815 | 0 | } else { |
1816 | 0 | individual_results_nonfinal.emplace(wtxid, single_res); |
1817 | 0 | txns_package_eval.push_back(tx); |
1818 | 0 | } |
1819 | 0 | } |
1820 | 0 | } |
1821 | | |
1822 | 0 | auto multi_submission_result = quit_early || txns_package_eval.empty() ? PackageMempoolAcceptResult(package_state_quit_early, {}) : Branch (1822:36): [True: 0, False: 0]
Branch (1822:50): [True: 0, False: 0]
|
1823 | 0 | AcceptSubPackage(txns_package_eval, args); |
1824 | 0 | PackageValidationState& package_state_final = multi_submission_result.m_state; |
1825 | | |
1826 | | // Make sure we haven't exceeded max mempool size. |
1827 | | // Package transactions that were submitted to mempool or already in mempool may be evicted. |
1828 | 0 | LimitMempoolSize(m_pool, m_active_chainstate.CoinsTip()); |
1829 | |
|
1830 | 0 | for (const auto& tx : package) { Branch (1830:25): [True: 0, False: 0]
|
1831 | 0 | const auto& wtxid = tx->GetWitnessHash(); |
1832 | 0 | if (multi_submission_result.m_tx_results.count(wtxid) > 0) { Branch (1832:13): [True: 0, False: 0]
|
1833 | | // We shouldn't have re-submitted if the tx result was already in results_final. |
1834 | 0 | Assume(results_final.count(wtxid) == 0); |
1835 | | // If it was submitted, check to see if the tx is still in the mempool. It could have |
1836 | | // been evicted due to LimitMempoolSize() above. |
1837 | 0 | const auto& txresult = multi_submission_result.m_tx_results.at(wtxid); |
1838 | 0 | if (txresult.m_result_type == MempoolAcceptResult::ResultType::VALID && !m_pool.exists(GenTxid::Wtxid(wtxid))) { Branch (1838:17): [True: 0, False: 0]
Branch (1838:17): [True: 0, False: 0]
Branch (1838:85): [True: 0, False: 0]
|
1839 | 0 | package_state_final.Invalid(PackageValidationResult::PCKG_TX, "transaction failed"); |
1840 | 0 | TxValidationState mempool_full_state; |
1841 | 0 | mempool_full_state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "mempool full"); |
1842 | 0 | results_final.emplace(wtxid, MempoolAcceptResult::Failure(mempool_full_state)); |
1843 | 0 | } else { |
1844 | 0 | results_final.emplace(wtxid, txresult); |
1845 | 0 | } |
1846 | 0 | } else if (const auto it{results_final.find(wtxid)}; it != results_final.end()) { Branch (1846:62): [True: 0, False: 0]
|
1847 | | // Already-in-mempool transaction. Check to see if it's still there, as it could have |
1848 | | // been evicted when LimitMempoolSize() was called. |
1849 | 0 | Assume(it->second.m_result_type != MempoolAcceptResult::ResultType::INVALID); |
1850 | 0 | Assume(individual_results_nonfinal.count(wtxid) == 0); |
1851 | | // Query by txid to include the same-txid-different-witness ones. |
1852 | 0 | if (!m_pool.exists(GenTxid::Txid(tx->GetHash()))) { Branch (1852:17): [True: 0, False: 0]
|
1853 | 0 | package_state_final.Invalid(PackageValidationResult::PCKG_TX, "transaction failed"); |
1854 | 0 | TxValidationState mempool_full_state; |
1855 | 0 | mempool_full_state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "mempool full"); |
1856 | | // Replace the previous result. |
1857 | 0 | results_final.erase(wtxid); |
1858 | 0 | results_final.emplace(wtxid, MempoolAcceptResult::Failure(mempool_full_state)); |
1859 | 0 | } |
1860 | 0 | } else if (const auto it{individual_results_nonfinal.find(wtxid)}; it != individual_results_nonfinal.end()) { Branch (1860:76): [True: 0, False: 0]
|
1861 | 0 | Assume(it->second.m_result_type == MempoolAcceptResult::ResultType::INVALID); |
1862 | | // Interesting result from previous processing. |
1863 | 0 | results_final.emplace(wtxid, it->second); |
1864 | 0 | } |
1865 | 0 | } |
1866 | 0 | Assume(results_final.size() == package.size()); |
1867 | 0 | return PackageMempoolAcceptResult(package_state_final, std::move(results_final)); |
1868 | 0 | } |
1869 | | |
1870 | | } // anon namespace |
1871 | | |
1872 | | MempoolAcceptResult AcceptToMemoryPool(Chainstate& active_chainstate, const CTransactionRef& tx, |
1873 | | int64_t accept_time, bool bypass_limits, bool test_accept) |
1874 | 0 | { |
1875 | 0 | AssertLockHeld(::cs_main); |
1876 | 0 | const CChainParams& chainparams{active_chainstate.m_chainman.GetParams()}; |
1877 | 0 | assert(active_chainstate.GetMempool() != nullptr); |
1878 | 0 | CTxMemPool& pool{*active_chainstate.GetMempool()}; |
1879 | |
|
1880 | 0 | std::vector<COutPoint> coins_to_uncache; |
1881 | 0 | auto args = MemPoolAccept::ATMPArgs::SingleAccept(chainparams, accept_time, bypass_limits, coins_to_uncache, test_accept); |
1882 | 0 | MempoolAcceptResult result = MemPoolAccept(pool, active_chainstate).AcceptSingleTransaction(tx, args); |
1883 | 0 | if (result.m_result_type != MempoolAcceptResult::ResultType::VALID) { Branch (1883:9): [True: 0, False: 0]
|
1884 | | // Remove coins that were not present in the coins cache before calling |
1885 | | // AcceptSingleTransaction(); this is to prevent memory DoS in case we receive a large |
1886 | | // number of invalid transactions that attempt to overrun the in-memory coins cache |
1887 | | // (`CCoinsViewCache::cacheCoins`). |
1888 | |
|
1889 | 0 | for (const COutPoint& hashTx : coins_to_uncache) Branch (1889:38): [True: 0, False: 0]
|
1890 | 0 | active_chainstate.CoinsTip().Uncache(hashTx); |
1891 | 0 | TRACE2(mempool, rejected, |
1892 | 0 | tx->GetHash().data(), |
1893 | 0 | result.m_state.GetRejectReason().c_str() |
1894 | 0 | ); |
1895 | 0 | } |
1896 | | // After we've (potentially) uncached entries, ensure our coins cache is still within its size limits |
1897 | 0 | BlockValidationState state_dummy; |
1898 | 0 | active_chainstate.FlushStateToDisk(state_dummy, FlushStateMode::PERIODIC); |
1899 | 0 | return result; |
1900 | 0 | } |
1901 | | |
1902 | | PackageMempoolAcceptResult ProcessNewPackage(Chainstate& active_chainstate, CTxMemPool& pool, |
1903 | | const Package& package, bool test_accept, const std::optional<CFeeRate>& client_maxfeerate) |
1904 | 0 | { |
1905 | 0 | AssertLockHeld(cs_main); |
1906 | 0 | assert(!package.empty()); |
1907 | 0 | assert(std::all_of(package.cbegin(), package.cend(), [](const auto& tx){return tx != nullptr;})); |
1908 | | |
1909 | 0 | std::vector<COutPoint> coins_to_uncache; |
1910 | 0 | const CChainParams& chainparams = active_chainstate.m_chainman.GetParams(); |
1911 | 0 | auto result = [&]() EXCLUSIVE_LOCKS_REQUIRED(cs_main) { |
1912 | 0 | AssertLockHeld(cs_main); |
1913 | 0 | if (test_accept) { Branch (1913:13): [True: 0, False: 0]
|
1914 | 0 | auto args = MemPoolAccept::ATMPArgs::PackageTestAccept(chainparams, GetTime(), coins_to_uncache); |
1915 | 0 | return MemPoolAccept(pool, active_chainstate).AcceptMultipleTransactions(package, args); |
1916 | 0 | } else { |
1917 | 0 | auto args = MemPoolAccept::ATMPArgs::PackageChildWithParents(chainparams, GetTime(), coins_to_uncache, client_maxfeerate); |
1918 | 0 | return MemPoolAccept(pool, active_chainstate).AcceptPackage(package, args); |
1919 | 0 | } |
1920 | 0 | }(); |
1921 | | |
1922 | | // Uncache coins pertaining to transactions that were not submitted to the mempool. |
1923 | 0 | if (test_accept || result.m_state.IsInvalid()) { Branch (1923:9): [True: 0, False: 0]
Branch (1923:24): [True: 0, False: 0]
|
1924 | 0 | for (const COutPoint& hashTx : coins_to_uncache) { Branch (1924:38): [True: 0, False: 0]
|
1925 | 0 | active_chainstate.CoinsTip().Uncache(hashTx); |
1926 | 0 | } |
1927 | 0 | } |
1928 | | // Ensure the coins cache is still within limits. |
1929 | 0 | BlockValidationState state_dummy; |
1930 | 0 | active_chainstate.FlushStateToDisk(state_dummy, FlushStateMode::PERIODIC); |
1931 | 0 | return result; |
1932 | 0 | } |
1933 | | |
1934 | | CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusParams) |
1935 | 0 | { |
1936 | 0 | int halvings = nHeight / consensusParams.nSubsidyHalvingInterval; |
1937 | | // Force block reward to zero when right shift is undefined. |
1938 | 0 | if (halvings >= 64) Branch (1938:9): [True: 0, False: 0]
|
1939 | 0 | return 0; |
1940 | | |
1941 | 0 | CAmount nSubsidy = 50 * COIN; |
1942 | | // Subsidy is cut in half every 210,000 blocks which will occur approximately every 4 years. |
1943 | 0 | nSubsidy >>= halvings; |
1944 | 0 | return nSubsidy; |
1945 | 0 | } |
1946 | | |
1947 | | CoinsViews::CoinsViews(DBParams db_params, CoinsViewOptions options) |
1948 | 0 | : m_dbview{std::move(db_params), std::move(options)}, |
1949 | 0 | m_catcherview(&m_dbview) {} |
1950 | | |
1951 | | void CoinsViews::InitCache() |
1952 | 0 | { |
1953 | 0 | AssertLockHeld(::cs_main); |
1954 | 0 | m_cacheview = std::make_unique<CCoinsViewCache>(&m_catcherview); |
1955 | 0 | } |
1956 | | |
1957 | | Chainstate::Chainstate( |
1958 | | CTxMemPool* mempool, |
1959 | | BlockManager& blockman, |
1960 | | ChainstateManager& chainman, |
1961 | | std::optional<uint256> from_snapshot_blockhash) |
1962 | 0 | : m_mempool(mempool), |
1963 | 0 | m_blockman(blockman), |
1964 | 0 | m_chainman(chainman), |
1965 | 0 | m_from_snapshot_blockhash(from_snapshot_blockhash) {} |
1966 | | |
1967 | | const CBlockIndex* Chainstate::SnapshotBase() |
1968 | 6.84k | { |
1969 | 6.84k | if (!m_from_snapshot_blockhash) return nullptr; Branch (1969:9): [True: 6.84k, False: 0]
|
1970 | 0 | if (!m_cached_snapshot_base) m_cached_snapshot_base = Assert(m_chainman.m_blockman.LookupBlockIndex(*m_from_snapshot_blockhash)); Branch (1970:9): [True: 0, False: 0]
|
1971 | 0 | return m_cached_snapshot_base; |
1972 | 6.84k | } |
1973 | | |
1974 | | void Chainstate::InitCoinsDB( |
1975 | | size_t cache_size_bytes, |
1976 | | bool in_memory, |
1977 | | bool should_wipe, |
1978 | | fs::path leveldb_name) |
1979 | 0 | { |
1980 | 0 | if (m_from_snapshot_blockhash) { Branch (1980:9): [True: 0, False: 0]
|
1981 | 0 | leveldb_name += node::SNAPSHOT_CHAINSTATE_SUFFIX; |
1982 | 0 | } |
1983 | |
|
1984 | 0 | m_coins_views = std::make_unique<CoinsViews>( |
1985 | 0 | DBParams{ |
1986 | 0 | .path = m_chainman.m_options.datadir / leveldb_name, |
1987 | 0 | .cache_bytes = cache_size_bytes, |
1988 | 0 | .memory_only = in_memory, |
1989 | 0 | .wipe_data = should_wipe, |
1990 | 0 | .obfuscate = true, |
1991 | 0 | .options = m_chainman.m_options.coins_db}, |
1992 | 0 | m_chainman.m_options.coins_view); |
1993 | 0 | } |
1994 | | |
1995 | | void Chainstate::InitCoinsCache(size_t cache_size_bytes) |
1996 | 0 | { |
1997 | 0 | AssertLockHeld(::cs_main); |
1998 | 0 | assert(m_coins_views != nullptr); |
1999 | 0 | m_coinstip_cache_size_bytes = cache_size_bytes; |
2000 | 0 | m_coins_views->InitCache(); |
2001 | 0 | } |
2002 | | |
2003 | | // Note that though this is marked const, we may end up modifying `m_cached_finished_ibd`, which |
2004 | | // is a performance-related implementation detail. This function must be marked |
2005 | | // `const` so that `CValidationInterface` clients (which are given a `const Chainstate*`) |
2006 | | // can call it. |
2007 | | // |
2008 | | bool ChainstateManager::IsInitialBlockDownload() const |
2009 | 14.4k | { |
2010 | | // Optimization: pre-test latch before taking the lock. |
2011 | 14.4k | if (m_cached_finished_ibd.load(std::memory_order_relaxed)) Branch (2011:9): [True: 0, False: 14.4k]
|
2012 | 0 | return false; |
2013 | | |
2014 | 14.4k | LOCK(cs_main); |
2015 | 14.4k | if (m_cached_finished_ibd.load(std::memory_order_relaxed)) Branch (2015:9): [True: 0, False: 14.4k]
|
2016 | 0 | return false; |
2017 | 14.4k | if (m_blockman.LoadingBlocks()) { Branch (2017:9): [True: 0, False: 14.4k]
|
2018 | 0 | return true; |
2019 | 0 | } |
2020 | 14.4k | CChain& chain{ActiveChain()}; |
2021 | 14.4k | if (chain.Tip() == nullptr) { Branch (2021:9): [True: 0, False: 14.4k]
|
2022 | 0 | return true; |
2023 | 0 | } |
2024 | 14.4k | if (chain.Tip()->nChainWork < MinimumChainWork()) { Branch (2024:9): [True: 14.4k, False: 0]
|
2025 | 14.4k | return true; |
2026 | 14.4k | } |
2027 | 0 | if (chain.Tip()->Time() < Now<NodeSeconds>() - m_options.max_tip_age) { Branch (2027:9): [True: 0, False: 0]
|
2028 | 0 | return true; |
2029 | 0 | } |
2030 | 0 | LogPrintf("Leaving InitialBlockDownload (latching to false)\n"); |
2031 | 0 | m_cached_finished_ibd.store(true, std::memory_order_relaxed); |
2032 | 0 | return false; |
2033 | 0 | } |
2034 | | |
2035 | | void Chainstate::CheckForkWarningConditions() |
2036 | 0 | { |
2037 | 0 | AssertLockHeld(cs_main); |
2038 | | |
2039 | | // Before we get past initial download, we cannot reliably alert about forks |
2040 | | // (we assume we don't get stuck on a fork before finishing our initial sync) |
2041 | 0 | if (m_chainman.IsInitialBlockDownload()) { Branch (2041:9): [True: 0, False: 0]
|
2042 | 0 | return; |
2043 | 0 | } |
2044 | | |
2045 | 0 | if (m_chainman.m_best_invalid && m_chainman.m_best_invalid->nChainWork > m_chain.Tip()->nChainWork + (GetBlockProof(*m_chain.Tip()) * 6)) { Branch (2045:9): [True: 0, False: 0]
Branch (2045:9): [True: 0, False: 0]
Branch (2045:38): [True: 0, False: 0]
|
2046 | 0 | LogPrintf("%s: Warning: Found invalid chain at least ~6 blocks longer than our best chain.\nChain state database corruption likely.\n", __func__); |
2047 | 0 | m_chainman.GetNotifications().warningSet( |
2048 | 0 | kernel::Warning::LARGE_WORK_INVALID_CHAIN, |
2049 | 0 | _("Warning: We do not appear to fully agree with our peers! You may need to upgrade, or other nodes may need to upgrade.")); |
2050 | 0 | } else { |
2051 | 0 | m_chainman.GetNotifications().warningUnset(kernel::Warning::LARGE_WORK_INVALID_CHAIN); |
2052 | 0 | } |
2053 | 0 | } |
2054 | | |
2055 | | // Called both upon regular invalid block discovery *and* InvalidateBlock |
2056 | | void Chainstate::InvalidChainFound(CBlockIndex* pindexNew) |
2057 | 0 | { |
2058 | 0 | AssertLockHeld(cs_main); |
2059 | 0 | if (!m_chainman.m_best_invalid || pindexNew->nChainWork > m_chainman.m_best_invalid->nChainWork) { Branch (2059:9): [True: 0, False: 0]
Branch (2059:39): [True: 0, False: 0]
|
2060 | 0 | m_chainman.m_best_invalid = pindexNew; |
2061 | 0 | } |
2062 | 0 | if (m_chainman.m_best_header != nullptr && m_chainman.m_best_header->GetAncestor(pindexNew->nHeight) == pindexNew) { Branch (2062:9): [True: 0, False: 0]
Branch (2062:48): [True: 0, False: 0]
|
2063 | 0 | m_chainman.m_best_header = m_chain.Tip(); |
2064 | 0 | } |
2065 | |
|
2066 | 0 | LogPrintf("%s: invalid block=%s height=%d log2_work=%f date=%s\n", __func__, |
2067 | 0 | pindexNew->GetBlockHash().ToString(), pindexNew->nHeight, |
2068 | 0 | log(pindexNew->nChainWork.getdouble())/log(2.0), FormatISO8601DateTime(pindexNew->GetBlockTime())); |
2069 | 0 | CBlockIndex *tip = m_chain.Tip(); |
2070 | 0 | assert (tip); |
2071 | 0 | LogPrintf("%s: current best=%s height=%d log2_work=%f date=%s\n", __func__, |
2072 | 0 | tip->GetBlockHash().ToString(), m_chain.Height(), log(tip->nChainWork.getdouble())/log(2.0), |
2073 | 0 | FormatISO8601DateTime(tip->GetBlockTime())); |
2074 | 0 | CheckForkWarningConditions(); |
2075 | 0 | } |
2076 | | |
2077 | | // Same as InvalidChainFound, above, except not called directly from InvalidateBlock, |
2078 | | // which does its own setBlockIndexCandidates management. |
2079 | | void Chainstate::InvalidBlockFound(CBlockIndex* pindex, const BlockValidationState& state) |
2080 | 0 | { |
2081 | 0 | AssertLockHeld(cs_main); |
2082 | 0 | if (state.GetResult() != BlockValidationResult::BLOCK_MUTATED) { Branch (2082:9): [True: 0, False: 0]
|
2083 | 0 | pindex->nStatus |= BLOCK_FAILED_VALID; |
2084 | 0 | m_chainman.m_failed_blocks.insert(pindex); |
2085 | 0 | m_blockman.m_dirty_blockindex.insert(pindex); |
2086 | 0 | setBlockIndexCandidates.erase(pindex); |
2087 | 0 | InvalidChainFound(pindex); |
2088 | 0 | } |
2089 | 0 | } |
2090 | | |
2091 | | void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, CTxUndo &txundo, int nHeight) |
2092 | 0 | { |
2093 | | // mark inputs spent |
2094 | 0 | if (!tx.IsCoinBase()) { Branch (2094:9): [True: 0, False: 0]
|
2095 | 0 | txundo.vprevout.reserve(tx.vin.size()); |
2096 | 0 | for (const CTxIn &txin : tx.vin) { Branch (2096:32): [True: 0, False: 0]
|
2097 | 0 | txundo.vprevout.emplace_back(); |
2098 | 0 | bool is_spent = inputs.SpendCoin(txin.prevout, &txundo.vprevout.back()); |
2099 | 0 | assert(is_spent); |
2100 | 0 | } |
2101 | 0 | } |
2102 | | // add outputs |
2103 | 0 | AddCoins(inputs, tx, nHeight); |
2104 | 0 | } |
2105 | | |
2106 | 0 | bool CScriptCheck::operator()() { |
2107 | 0 | const CScript &scriptSig = ptxTo->vin[nIn].scriptSig; |
2108 | 0 | const CScriptWitness *witness = &ptxTo->vin[nIn].scriptWitness; |
2109 | 0 | return VerifyScript(scriptSig, m_tx_out.scriptPubKey, witness, nFlags, CachingTransactionSignatureChecker(ptxTo, nIn, m_tx_out.nValue, cacheStore, *m_signature_cache, *txdata), &error); |
2110 | 0 | } |
2111 | | |
2112 | | ValidationCache::ValidationCache(const size_t script_execution_cache_bytes, const size_t signature_cache_bytes) |
2113 | 0 | : m_signature_cache{signature_cache_bytes} |
2114 | 0 | { |
2115 | | // Setup the salted hasher |
2116 | 0 | uint256 nonce = GetRandHash(); |
2117 | | // We want the nonce to be 64 bytes long to force the hasher to process |
2118 | | // this chunk, which makes later hash computations more efficient. We |
2119 | | // just write our 32-byte entropy twice to fill the 64 bytes. |
2120 | 0 | m_script_execution_cache_hasher.Write(nonce.begin(), 32); |
2121 | 0 | m_script_execution_cache_hasher.Write(nonce.begin(), 32); |
2122 | |
|
2123 | 0 | const auto [num_elems, approx_size_bytes] = m_script_execution_cache.setup_bytes(script_execution_cache_bytes); |
2124 | 0 | LogPrintf("Using %zu MiB out of %zu MiB requested for script execution cache, able to store %zu elements\n", |
2125 | 0 | approx_size_bytes >> 20, script_execution_cache_bytes >> 20, num_elems); |
2126 | 0 | } |
2127 | | |
2128 | | /** |
2129 | | * Check whether all of this transaction's input scripts succeed. |
2130 | | * |
2131 | | * This involves ECDSA signature checks so can be computationally intensive. This function should |
2132 | | * only be called after the cheap sanity checks in CheckTxInputs passed. |
2133 | | * |
2134 | | * If pvChecks is not nullptr, script checks are pushed onto it instead of being performed inline. Any |
2135 | | * script checks which are not necessary (eg due to script execution cache hits) are, obviously, |
2136 | | * not pushed onto pvChecks/run. |
2137 | | * |
2138 | | * Setting cacheSigStore/cacheFullScriptStore to false will remove elements from the corresponding cache |
2139 | | * which are matched. This is useful for checking blocks where we will likely never need the cache |
2140 | | * entry again. |
2141 | | * |
2142 | | * Note that we may set state.reason to NOT_STANDARD for extra soft-fork flags in flags, block-checking |
2143 | | * callers should probably reset it to CONSENSUS in such cases. |
2144 | | * |
2145 | | * Non-static (and redeclared) in src/test/txvalidationcache_tests.cpp |
2146 | | */ |
2147 | | bool CheckInputScripts(const CTransaction& tx, TxValidationState& state, |
2148 | | const CCoinsViewCache& inputs, unsigned int flags, bool cacheSigStore, |
2149 | | bool cacheFullScriptStore, PrecomputedTransactionData& txdata, |
2150 | | ValidationCache& validation_cache, |
2151 | | std::vector<CScriptCheck>* pvChecks) |
2152 | 0 | { |
2153 | 0 | if (tx.IsCoinBase()) return true; Branch (2153:9): [True: 0, False: 0]
|
2154 | | |
2155 | 0 | if (pvChecks) { Branch (2155:9): [True: 0, False: 0]
|
2156 | 0 | pvChecks->reserve(tx.vin.size()); |
2157 | 0 | } |
2158 | | |
2159 | | // First check if script executions have been cached with the same |
2160 | | // flags. Note that this assumes that the inputs provided are |
2161 | | // correct (ie that the transaction hash which is in tx's prevouts |
2162 | | // properly commits to the scriptPubKey in the inputs view of that |
2163 | | // transaction). |
2164 | 0 | uint256 hashCacheEntry; |
2165 | 0 | CSHA256 hasher = validation_cache.ScriptExecutionCacheHasher(); |
2166 | 0 | hasher.Write(UCharCast(tx.GetWitnessHash().begin()), 32).Write((unsigned char*)&flags, sizeof(flags)).Finalize(hashCacheEntry.begin()); |
2167 | 0 | AssertLockHeld(cs_main); //TODO: Remove this requirement by making CuckooCache not require external locks |
2168 | 0 | if (validation_cache.m_script_execution_cache.contains(hashCacheEntry, !cacheFullScriptStore)) { Branch (2168:9): [True: 0, False: 0]
|
2169 | 0 | return true; |
2170 | 0 | } |
2171 | | |
2172 | 0 | if (!txdata.m_spent_outputs_ready) { Branch (2172:9): [True: 0, False: 0]
|
2173 | 0 | std::vector<CTxOut> spent_outputs; |
2174 | 0 | spent_outputs.reserve(tx.vin.size()); |
2175 | |
|
2176 | 0 | for (const auto& txin : tx.vin) { Branch (2176:31): [True: 0, False: 0]
|
2177 | 0 | const COutPoint& prevout = txin.prevout; |
2178 | 0 | const Coin& coin = inputs.AccessCoin(prevout); |
2179 | 0 | assert(!coin.IsSpent()); |
2180 | 0 | spent_outputs.emplace_back(coin.out); |
2181 | 0 | } |
2182 | 0 | txdata.Init(tx, std::move(spent_outputs)); |
2183 | 0 | } |
2184 | 0 | assert(txdata.m_spent_outputs.size() == tx.vin.size()); |
2185 | | |
2186 | 0 | for (unsigned int i = 0; i < tx.vin.size(); i++) { Branch (2186:30): [True: 0, False: 0]
|
2187 | | |
2188 | | // We very carefully only pass in things to CScriptCheck which |
2189 | | // are clearly committed to by tx' witness hash. This provides |
2190 | | // a sanity check that our caching is not introducing consensus |
2191 | | // failures through additional data in, eg, the coins being |
2192 | | // spent being checked as a part of CScriptCheck. |
2193 | | |
2194 | | // Verify signature |
2195 | 0 | CScriptCheck check(txdata.m_spent_outputs[i], tx, validation_cache.m_signature_cache, i, flags, cacheSigStore, &txdata); |
2196 | 0 | if (pvChecks) { Branch (2196:13): [True: 0, False: 0]
|
2197 | 0 | pvChecks->emplace_back(std::move(check)); |
2198 | 0 | } else if (!check()) { Branch (2198:20): [True: 0, False: 0]
|
2199 | 0 | if (flags & STANDARD_NOT_MANDATORY_VERIFY_FLAGS) { Branch (2199:17): [True: 0, False: 0]
|
2200 | | // Check whether the failure was caused by a |
2201 | | // non-mandatory script verification check, such as |
2202 | | // non-standard DER encodings or non-null dummy |
2203 | | // arguments; if so, ensure we return NOT_STANDARD |
2204 | | // instead of CONSENSUS to avoid downstream users |
2205 | | // splitting the network between upgraded and |
2206 | | // non-upgraded nodes by banning CONSENSUS-failing |
2207 | | // data providers. |
2208 | 0 | CScriptCheck check2(txdata.m_spent_outputs[i], tx, validation_cache.m_signature_cache, i, |
2209 | 0 | flags & ~STANDARD_NOT_MANDATORY_VERIFY_FLAGS, cacheSigStore, &txdata); |
2210 | 0 | if (check2()) Branch (2210:21): [True: 0, False: 0]
|
2211 | 0 | return state.Invalid(TxValidationResult::TX_NOT_STANDARD, strprintf("non-mandatory-script-verify-flag (%s)", ScriptErrorString(check.GetScriptError()))); |
2212 | 0 | } |
2213 | | // MANDATORY flag failures correspond to |
2214 | | // TxValidationResult::TX_CONSENSUS. Because CONSENSUS |
2215 | | // failures are the most serious case of validation |
2216 | | // failures, we may need to consider using |
2217 | | // RECENT_CONSENSUS_CHANGE for any script failure that |
2218 | | // could be due to non-upgraded nodes which we may want to |
2219 | | // support, to avoid splitting the network (but this |
2220 | | // depends on the details of how net_processing handles |
2221 | | // such errors). |
2222 | 0 | return state.Invalid(TxValidationResult::TX_CONSENSUS, strprintf("mandatory-script-verify-flag-failed (%s)", ScriptErrorString(check.GetScriptError()))); |
2223 | 0 | } |
2224 | 0 | } |
2225 | | |
2226 | 0 | if (cacheFullScriptStore && !pvChecks) { Branch (2226:9): [True: 0, False: 0]
Branch (2226:33): [True: 0, False: 0]
|
2227 | | // We executed all of the provided scripts, and were told to |
2228 | | // cache the result. Do so now. |
2229 | 0 | validation_cache.m_script_execution_cache.insert(hashCacheEntry); |
2230 | 0 | } |
2231 | |
|
2232 | 0 | return true; |
2233 | 0 | } |
2234 | | |
2235 | | bool FatalError(Notifications& notifications, BlockValidationState& state, const bilingual_str& message) |
2236 | 0 | { |
2237 | 0 | notifications.fatalError(message); |
2238 | 0 | return state.Error(message.original); |
2239 | 0 | } |
2240 | | |
2241 | | /** |
2242 | | * Restore the UTXO in a Coin at a given COutPoint |
2243 | | * @param undo The Coin to be restored. |
2244 | | * @param view The coins view to which to apply the changes. |
2245 | | * @param out The out point that corresponds to the tx input. |
2246 | | * @return A DisconnectResult as an int |
2247 | | */ |
2248 | | int ApplyTxInUndo(Coin&& undo, CCoinsViewCache& view, const COutPoint& out) |
2249 | 0 | { |
2250 | 0 | bool fClean = true; |
2251 | |
|
2252 | 0 | if (view.HaveCoin(out)) fClean = false; // overwriting transaction output Branch (2252:9): [True: 0, False: 0]
|
2253 | |
|
2254 | 0 | if (undo.nHeight == 0) { Branch (2254:9): [True: 0, False: 0]
|
2255 | | // Missing undo metadata (height and coinbase). Older versions included this |
2256 | | // information only in undo records for the last spend of a transactions' |
2257 | | // outputs. This implies that it must be present for some other output of the same tx. |
2258 | 0 | const Coin& alternate = AccessByTxid(view, out.hash); |
2259 | 0 | if (!alternate.IsSpent()) { Branch (2259:13): [True: 0, False: 0]
|
2260 | 0 | undo.nHeight = alternate.nHeight; |
2261 | 0 | undo.fCoinBase = alternate.fCoinBase; |
2262 | 0 | } else { |
2263 | 0 | return DISCONNECT_FAILED; // adding output for transaction without known metadata |
2264 | 0 | } |
2265 | 0 | } |
2266 | | // If the coin already exists as an unspent coin in the cache, then the |
2267 | | // possible_overwrite parameter to AddCoin must be set to true. We have |
2268 | | // already checked whether an unspent coin exists above using HaveCoin, so |
2269 | | // we don't need to guess. When fClean is false, an unspent coin already |
2270 | | // existed and it is an overwrite. |
2271 | 0 | view.AddCoin(out, std::move(undo), !fClean); |
2272 | |
|
2273 | 0 | return fClean ? DISCONNECT_OK : DISCONNECT_UNCLEAN; Branch (2273:12): [True: 0, False: 0]
|
2274 | 0 | } |
2275 | | |
2276 | | /** Undo the effects of this block (with given index) on the UTXO set represented by coins. |
2277 | | * When FAILED is returned, view is left in an indeterminate state. */ |
2278 | | DisconnectResult Chainstate::DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view) |
2279 | 0 | { |
2280 | 0 | AssertLockHeld(::cs_main); |
2281 | 0 | bool fClean = true; |
2282 | |
|
2283 | 0 | CBlockUndo blockUndo; |
2284 | 0 | if (!m_blockman.UndoReadFromDisk(blockUndo, *pindex)) { Branch (2284:9): [True: 0, False: 0]
|
2285 | 0 | LogError("DisconnectBlock(): failure reading undo data\n"); |
2286 | 0 | return DISCONNECT_FAILED; |
2287 | 0 | } |
2288 | | |
2289 | 0 | if (blockUndo.vtxundo.size() + 1 != block.vtx.size()) { Branch (2289:9): [True: 0, False: 0]
|
2290 | 0 | LogError("DisconnectBlock(): block and undo data inconsistent\n"); |
2291 | 0 | return DISCONNECT_FAILED; |
2292 | 0 | } |
2293 | | |
2294 | | // Ignore blocks that contain transactions which are 'overwritten' by later transactions, |
2295 | | // unless those are already completely spent. |
2296 | | // See https://github.com/bitcoin/bitcoin/issues/22596 for additional information. |
2297 | | // Note: the blocks specified here are different than the ones used in ConnectBlock because DisconnectBlock |
2298 | | // unwinds the blocks in reverse. As a result, the inconsistency is not discovered until the earlier |
2299 | | // blocks with the duplicate coinbase transactions are disconnected. |
2300 | 0 | bool fEnforceBIP30 = !((pindex->nHeight==91722 && pindex->GetBlockHash() == uint256{"00000000000271a2dc26e7667f8419f2e15416dc6955e5a6c6cdf3f2574dd08e"}) || Branch (2300:29): [True: 0, False: 0]
Branch (2300:55): [True: 0, False: 0]
|
2301 | 0 | (pindex->nHeight==91812 && pindex->GetBlockHash() == uint256{"00000000000af0aed4792b1acee3d966af36cf5def14935db8de83d6f9306f2f"})); Branch (2301:29): [True: 0, False: 0]
Branch (2301:55): [True: 0, False: 0]
|
2302 | | |
2303 | | // undo transactions in reverse order |
2304 | 0 | for (int i = block.vtx.size() - 1; i >= 0; i--) { Branch (2304:40): [True: 0, False: 0]
|
2305 | 0 | const CTransaction &tx = *(block.vtx[i]); |
2306 | 0 | Txid hash = tx.GetHash(); |
2307 | 0 | bool is_coinbase = tx.IsCoinBase(); |
2308 | 0 | bool is_bip30_exception = (is_coinbase && !fEnforceBIP30); Branch (2308:36): [True: 0, False: 0]
Branch (2308:51): [True: 0, False: 0]
|
2309 | | |
2310 | | // Check that all outputs are available and match the outputs in the block itself |
2311 | | // exactly. |
2312 | 0 | for (size_t o = 0; o < tx.vout.size(); o++) { Branch (2312:28): [True: 0, False: 0]
|
2313 | 0 | if (!tx.vout[o].scriptPubKey.IsUnspendable()) { Branch (2313:17): [True: 0, False: 0]
|
2314 | 0 | COutPoint out(hash, o); |
2315 | 0 | Coin coin; |
2316 | 0 | bool is_spent = view.SpendCoin(out, &coin); |
2317 | 0 | if (!is_spent || tx.vout[o] != coin.out || pindex->nHeight != coin.nHeight || is_coinbase != coin.fCoinBase) { Branch (2317:21): [True: 0, False: 0]
Branch (2317:34): [True: 0, False: 0]
Branch (2317:60): [True: 0, False: 0]
Branch (2317:95): [True: 0, False: 0]
|
2318 | 0 | if (!is_bip30_exception) { Branch (2318:25): [True: 0, False: 0]
|
2319 | 0 | fClean = false; // transaction output mismatch |
2320 | 0 | } |
2321 | 0 | } |
2322 | 0 | } |
2323 | 0 | } |
2324 | | |
2325 | | // restore inputs |
2326 | 0 | if (i > 0) { // not coinbases Branch (2326:13): [True: 0, False: 0]
|
2327 | 0 | CTxUndo &txundo = blockUndo.vtxundo[i-1]; |
2328 | 0 | if (txundo.vprevout.size() != tx.vin.size()) { Branch (2328:17): [True: 0, False: 0]
|
2329 | 0 | LogError("DisconnectBlock(): transaction and undo data inconsistent\n"); |
2330 | 0 | return DISCONNECT_FAILED; |
2331 | 0 | } |
2332 | 0 | for (unsigned int j = tx.vin.size(); j > 0;) { Branch (2332:50): [True: 0, False: 0]
|
2333 | 0 | --j; |
2334 | 0 | const COutPoint& out = tx.vin[j].prevout; |
2335 | 0 | int res = ApplyTxInUndo(std::move(txundo.vprevout[j]), view, out); |
2336 | 0 | if (res == DISCONNECT_FAILED) return DISCONNECT_FAILED; Branch (2336:21): [True: 0, False: 0]
|
2337 | 0 | fClean = fClean && res != DISCONNECT_UNCLEAN; Branch (2337:26): [True: 0, False: 0]
Branch (2337:36): [True: 0, False: 0]
|
2338 | 0 | } |
2339 | | // At this point, all of txundo.vprevout should have been moved out. |
2340 | 0 | } |
2341 | 0 | } |
2342 | | |
2343 | | // move best block pointer to prevout block |
2344 | 0 | view.SetBestBlock(pindex->pprev->GetBlockHash()); |
2345 | |
|
2346 | 0 | return fClean ? DISCONNECT_OK : DISCONNECT_UNCLEAN; Branch (2346:12): [True: 0, False: 0]
|
2347 | 0 | } |
2348 | | |
2349 | | /** |
2350 | | * Threshold condition checker that triggers when unknown versionbits are seen on the network. |
2351 | | */ |
2352 | | class WarningBitsConditionChecker : public AbstractThresholdConditionChecker |
2353 | | { |
2354 | | private: |
2355 | | const ChainstateManager& m_chainman; |
2356 | | int m_bit; |
2357 | | |
2358 | | public: |
2359 | 0 | explicit WarningBitsConditionChecker(const ChainstateManager& chainman, int bit) : m_chainman{chainman}, m_bit(bit) {} |
2360 | | |
2361 | 0 | int64_t BeginTime(const Consensus::Params& params) const override { return 0; } |
2362 | 0 | int64_t EndTime(const Consensus::Params& params) const override { return std::numeric_limits<int64_t>::max(); } |
2363 | 0 | int Period(const Consensus::Params& params) const override { return params.nMinerConfirmationWindow; } |
2364 | 0 | int Threshold(const Consensus::Params& params) const override { return params.nRuleChangeActivationThreshold; } |
2365 | | |
2366 | | bool Condition(const CBlockIndex* pindex, const Consensus::Params& params) const override |
2367 | 0 | { |
2368 | 0 | return pindex->nHeight >= params.MinBIP9WarningHeight && Branch (2368:16): [True: 0, False: 0]
|
2369 | 0 | ((pindex->nVersion & VERSIONBITS_TOP_MASK) == VERSIONBITS_TOP_BITS) && Branch (2369:16): [True: 0, False: 0]
|
2370 | 0 | ((pindex->nVersion >> m_bit) & 1) != 0 && Branch (2370:16): [True: 0, False: 0]
|
2371 | 0 | ((m_chainman.m_versionbitscache.ComputeBlockVersion(pindex->pprev, params) >> m_bit) & 1) == 0; Branch (2371:16): [True: 0, False: 0]
|
2372 | 0 | } |
2373 | | }; |
2374 | | |
2375 | | static unsigned int GetBlockScriptFlags(const CBlockIndex& block_index, const ChainstateManager& chainman) |
2376 | 0 | { |
2377 | 0 | const Consensus::Params& consensusparams = chainman.GetConsensus(); |
2378 | | |
2379 | | // BIP16 didn't become active until Apr 1 2012 (on mainnet, and |
2380 | | // retroactively applied to testnet) |
2381 | | // However, only one historical block violated the P2SH rules (on both |
2382 | | // mainnet and testnet). |
2383 | | // Similarly, only one historical block violated the TAPROOT rules on |
2384 | | // mainnet. |
2385 | | // For simplicity, always leave P2SH+WITNESS+TAPROOT on except for the two |
2386 | | // violating blocks. |
2387 | 0 | uint32_t flags{SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_TAPROOT}; |
2388 | 0 | const auto it{consensusparams.script_flag_exceptions.find(*Assert(block_index.phashBlock))}; |
2389 | 0 | if (it != consensusparams.script_flag_exceptions.end()) { Branch (2389:9): [True: 0, False: 0]
|
2390 | 0 | flags = it->second; |
2391 | 0 | } |
2392 | | |
2393 | | // Enforce the DERSIG (BIP66) rule |
2394 | 0 | if (DeploymentActiveAt(block_index, chainman, Consensus::DEPLOYMENT_DERSIG)) { Branch (2394:9): [True: 0, False: 0]
|
2395 | 0 | flags |= SCRIPT_VERIFY_DERSIG; |
2396 | 0 | } |
2397 | | |
2398 | | // Enforce CHECKLOCKTIMEVERIFY (BIP65) |
2399 | 0 | if (DeploymentActiveAt(block_index, chainman, Consensus::DEPLOYMENT_CLTV)) { Branch (2399:9): [True: 0, False: 0]
|
2400 | 0 | flags |= SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY; |
2401 | 0 | } |
2402 | | |
2403 | | // Enforce CHECKSEQUENCEVERIFY (BIP112) |
2404 | 0 | if (DeploymentActiveAt(block_index, chainman, Consensus::DEPLOYMENT_CSV)) { Branch (2404:9): [True: 0, False: 0]
|
2405 | 0 | flags |= SCRIPT_VERIFY_CHECKSEQUENCEVERIFY; |
2406 | 0 | } |
2407 | | |
2408 | | // Enforce BIP147 NULLDUMMY (activated simultaneously with segwit) |
2409 | 0 | if (DeploymentActiveAt(block_index, chainman, Consensus::DEPLOYMENT_SEGWIT)) { Branch (2409:9): [True: 0, False: 0]
|
2410 | 0 | flags |= SCRIPT_VERIFY_NULLDUMMY; |
2411 | 0 | } |
2412 | |
|
2413 | 0 | return flags; |
2414 | 0 | } |
2415 | | |
2416 | | |
2417 | | /** Apply the effects of this block (with given index) on the UTXO set represented by coins. |
2418 | | * Validity checks that depend on the UTXO set are also done; ConnectBlock() |
2419 | | * can fail if those validity checks fail (among other reasons). */ |
2420 | | bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state, CBlockIndex* pindex, |
2421 | | CCoinsViewCache& view, bool fJustCheck) |
2422 | 0 | { |
2423 | 0 | AssertLockHeld(cs_main); |
2424 | 0 | assert(pindex); |
2425 | | |
2426 | 0 | uint256 block_hash{block.GetHash()}; |
2427 | 0 | assert(*pindex->phashBlock == block_hash); |
2428 | 0 | const bool parallel_script_checks{m_chainman.GetCheckQueue().HasThreads()}; |
2429 | |
|
2430 | 0 | const auto time_start{SteadyClock::now()}; |
2431 | 0 | const CChainParams& params{m_chainman.GetParams()}; |
2432 | | |
2433 | | // Check it again in case a previous version let a bad block in |
2434 | | // NOTE: We don't currently (re-)invoke ContextualCheckBlock() or |
2435 | | // ContextualCheckBlockHeader() here. This means that if we add a new |
2436 | | // consensus rule that is enforced in one of those two functions, then we |
2437 | | // may have let in a block that violates the rule prior to updating the |
2438 | | // software, and we would NOT be enforcing the rule here. Fully solving |
2439 | | // upgrade from one software version to the next after a consensus rule |
2440 | | // change is potentially tricky and issue-specific (see NeedsRedownload() |
2441 | | // for one approach that was used for BIP 141 deployment). |
2442 | | // Also, currently the rule against blocks more than 2 hours in the future |
2443 | | // is enforced in ContextualCheckBlockHeader(); we wouldn't want to |
2444 | | // re-enforce that rule here (at least until we make it impossible for |
2445 | | // the clock to go backward). |
2446 | 0 | if (!CheckBlock(block, state, params.GetConsensus(), !fJustCheck, !fJustCheck)) { Branch (2446:9): [True: 0, False: 0]
|
2447 | 0 | if (state.GetResult() == BlockValidationResult::BLOCK_MUTATED) { Branch (2447:13): [True: 0, False: 0]
|
2448 | | // We don't write down blocks to disk if they may have been |
2449 | | // corrupted, so this should be impossible unless we're having hardware |
2450 | | // problems. |
2451 | 0 | return FatalError(m_chainman.GetNotifications(), state, _("Corrupt block found indicating potential hardware failure.")); |
2452 | 0 | } |
2453 | 0 | LogError("%s: Consensus::CheckBlock: %s\n", __func__, state.ToString()); |
2454 | 0 | return false; |
2455 | 0 | } |
2456 | | |
2457 | | // verify that the view's current state corresponds to the previous block |
2458 | 0 | uint256 hashPrevBlock = pindex->pprev == nullptr ? uint256() : pindex->pprev->GetBlockHash(); Branch (2458:29): [True: 0, False: 0]
|
2459 | 0 | assert(hashPrevBlock == view.GetBestBlock()); |
2460 | | |
2461 | 0 | m_chainman.num_blocks_total++; |
2462 | | |
2463 | | // Special case for the genesis block, skipping connection of its transactions |
2464 | | // (its coinbase is unspendable) |
2465 | 0 | if (block_hash == params.GetConsensus().hashGenesisBlock) { Branch (2465:9): [True: 0, False: 0]
|
2466 | 0 | if (!fJustCheck) Branch (2466:13): [True: 0, False: 0]
|
2467 | 0 | view.SetBestBlock(pindex->GetBlockHash()); |
2468 | 0 | return true; |
2469 | 0 | } |
2470 | | |
2471 | 0 | bool fScriptChecks = true; |
2472 | 0 | if (!m_chainman.AssumedValidBlock().IsNull()) { Branch (2472:9): [True: 0, False: 0]
|
2473 | | // We've been configured with the hash of a block which has been externally verified to have a valid history. |
2474 | | // A suitable default value is included with the software and updated from time to time. Because validity |
2475 | | // relative to a piece of software is an objective fact these defaults can be easily reviewed. |
2476 | | // This setting doesn't force the selection of any particular chain but makes validating some faster by |
2477 | | // effectively caching the result of part of the verification. |
2478 | 0 | BlockMap::const_iterator it{m_blockman.m_block_index.find(m_chainman.AssumedValidBlock())}; |
2479 | 0 | if (it != m_blockman.m_block_index.end()) { Branch (2479:13): [True: 0, False: 0]
|
2480 | 0 | if (it->second.GetAncestor(pindex->nHeight) == pindex && Branch (2480:17): [True: 0, False: 0]
|
2481 | 0 | m_chainman.m_best_header->GetAncestor(pindex->nHeight) == pindex && Branch (2481:17): [True: 0, False: 0]
|
2482 | 0 | m_chainman.m_best_header->nChainWork >= m_chainman.MinimumChainWork()) { Branch (2482:17): [True: 0, False: 0]
|
2483 | | // This block is a member of the assumed verified chain and an ancestor of the best header. |
2484 | | // Script verification is skipped when connecting blocks under the |
2485 | | // assumevalid block. Assuming the assumevalid block is valid this |
2486 | | // is safe because block merkle hashes are still computed and checked, |
2487 | | // Of course, if an assumed valid block is invalid due to false scriptSigs |
2488 | | // this optimization would allow an invalid chain to be accepted. |
2489 | | // The equivalent time check discourages hash power from extorting the network via DOS attack |
2490 | | // into accepting an invalid block through telling users they must manually set assumevalid. |
2491 | | // Requiring a software change or burying the invalid block, regardless of the setting, makes |
2492 | | // it hard to hide the implication of the demand. This also avoids having release candidates |
2493 | | // that are hardly doing any signature verification at all in testing without having to |
2494 | | // artificially set the default assumed verified block further back. |
2495 | | // The test against the minimum chain work prevents the skipping when denied access to any chain at |
2496 | | // least as good as the expected chain. |
2497 | 0 | fScriptChecks = (GetBlockProofEquivalentTime(*m_chainman.m_best_header, *pindex, *m_chainman.m_best_header, params.GetConsensus()) <= 60 * 60 * 24 * 7 * 2); |
2498 | 0 | } |
2499 | 0 | } |
2500 | 0 | } |
2501 | |
|
2502 | 0 | const auto time_1{SteadyClock::now()}; |
2503 | 0 | m_chainman.time_check += time_1 - time_start; |
2504 | 0 | LogPrint(BCLog::BENCH, " - Sanity checks: %.2fms [%.2fs (%.2fms/blk)]\n", |
2505 | 0 | Ticks<MillisecondsDouble>(time_1 - time_start), |
2506 | 0 | Ticks<SecondsDouble>(m_chainman.time_check), |
2507 | 0 | Ticks<MillisecondsDouble>(m_chainman.time_check) / m_chainman.num_blocks_total); |
2508 | | |
2509 | | // Do not allow blocks that contain transactions which 'overwrite' older transactions, |
2510 | | // unless those are already completely spent. |
2511 | | // If such overwrites are allowed, coinbases and transactions depending upon those |
2512 | | // can be duplicated to remove the ability to spend the first instance -- even after |
2513 | | // being sent to another address. |
2514 | | // See BIP30, CVE-2012-1909, and http://r6.ca/blog/20120206T005236Z.html for more information. |
2515 | | // This rule was originally applied to all blocks with a timestamp after March 15, 2012, 0:00 UTC. |
2516 | | // Now that the whole chain is irreversibly beyond that time it is applied to all blocks except the |
2517 | | // two in the chain that violate it. This prevents exploiting the issue against nodes during their |
2518 | | // initial block download. |
2519 | 0 | bool fEnforceBIP30 = !IsBIP30Repeat(*pindex); |
2520 | | |
2521 | | // Once BIP34 activated it was not possible to create new duplicate coinbases and thus other than starting |
2522 | | // with the 2 existing duplicate coinbase pairs, not possible to create overwriting txs. But by the |
2523 | | // time BIP34 activated, in each of the existing pairs the duplicate coinbase had overwritten the first |
2524 | | // before the first had been spent. Since those coinbases are sufficiently buried it's no longer possible to create further |
2525 | | // duplicate transactions descending from the known pairs either. |
2526 | | // 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. |
2527 | | |
2528 | | // BIP34 requires that a block at height X (block X) has its coinbase |
2529 | | // scriptSig start with a CScriptNum of X (indicated height X). The above |
2530 | | // logic of no longer requiring BIP30 once BIP34 activates is flawed in the |
2531 | | // case that there is a block X before the BIP34 height of 227,931 which has |
2532 | | // an indicated height Y where Y is greater than X. The coinbase for block |
2533 | | // X would also be a valid coinbase for block Y, which could be a BIP30 |
2534 | | // violation. An exhaustive search of all mainnet coinbases before the |
2535 | | // BIP34 height which have an indicated height greater than the block height |
2536 | | // reveals many occurrences. The 3 lowest indicated heights found are |
2537 | | // 209,921, 490,897, and 1,983,702 and thus coinbases for blocks at these 3 |
2538 | | // heights would be the first opportunity for BIP30 to be violated. |
2539 | | |
2540 | | // The search reveals a great many blocks which have an indicated height |
2541 | | // greater than 1,983,702, so we simply remove the optimization to skip |
2542 | | // BIP30 checking for blocks at height 1,983,702 or higher. Before we reach |
2543 | | // that block in another 25 years or so, we should take advantage of a |
2544 | | // future consensus change to do a new and improved version of BIP34 that |
2545 | | // will actually prevent ever creating any duplicate coinbases in the |
2546 | | // future. |
2547 | 0 | static constexpr int BIP34_IMPLIES_BIP30_LIMIT = 1983702; |
2548 | | |
2549 | | // There is no potential to create a duplicate coinbase at block 209,921 |
2550 | | // because this is still before the BIP34 height and so explicit BIP30 |
2551 | | // checking is still active. |
2552 | | |
2553 | | // The final case is block 176,684 which has an indicated height of |
2554 | | // 490,897. Unfortunately, this issue was not discovered until about 2 weeks |
2555 | | // before block 490,897 so there was not much opportunity to address this |
2556 | | // case other than to carefully analyze it and determine it would not be a |
2557 | | // problem. Block 490,897 was, in fact, mined with a different coinbase than |
2558 | | // block 176,684, but it is important to note that even if it hadn't been or |
2559 | | // is remined on an alternate fork with a duplicate coinbase, we would still |
2560 | | // not run into a BIP30 violation. This is because the coinbase for 176,684 |
2561 | | // is spent in block 185,956 in transaction |
2562 | | // d4f7fbbf92f4a3014a230b2dc70b8058d02eb36ac06b4a0736d9d60eaa9e8781. This |
2563 | | // spending transaction can't be duplicated because it also spends coinbase |
2564 | | // 0328dd85c331237f18e781d692c92de57649529bd5edf1d01036daea32ffde29. This |
2565 | | // coinbase has an indicated height of over 4.2 billion, and wouldn't be |
2566 | | // duplicatable until that height, and it's currently impossible to create a |
2567 | | // chain that long. Nevertheless we may wish to consider a future soft fork |
2568 | | // which retroactively prevents block 490,897 from creating a duplicate |
2569 | | // coinbase. The two historical BIP30 violations often provide a confusing |
2570 | | // edge case when manipulating the UTXO and it would be simpler not to have |
2571 | | // another edge case to deal with. |
2572 | | |
2573 | | // testnet3 has no blocks before the BIP34 height with indicated heights |
2574 | | // post BIP34 before approximately height 486,000,000. After block |
2575 | | // 1,983,702 testnet3 starts doing unnecessary BIP30 checking again. |
2576 | 0 | assert(pindex->pprev); |
2577 | 0 | CBlockIndex* pindexBIP34height = pindex->pprev->GetAncestor(params.GetConsensus().BIP34Height); |
2578 | | //Only continue to enforce if we're below BIP34 activation height or the block hash at that height doesn't correspond. |
2579 | 0 | fEnforceBIP30 = fEnforceBIP30 && (!pindexBIP34height || !(pindexBIP34height->GetBlockHash() == params.GetConsensus().BIP34Hash)); Branch (2579:21): [True: 0, False: 0]
Branch (2579:39): [True: 0, False: 0]
Branch (2579:61): [True: 0, False: 0]
|
2580 | | |
2581 | | // TODO: Remove BIP30 checking from block height 1,983,702 on, once we have a |
2582 | | // consensus change that ensures coinbases at those heights cannot |
2583 | | // duplicate earlier coinbases. |
2584 | 0 | if (fEnforceBIP30 || pindex->nHeight >= BIP34_IMPLIES_BIP30_LIMIT) { Branch (2584:9): [True: 0, False: 0]
Branch (2584:26): [True: 0, False: 0]
|
2585 | 0 | for (const auto& tx : block.vtx) { Branch (2585:29): [True: 0, False: 0]
|
2586 | 0 | for (size_t o = 0; o < tx->vout.size(); o++) { Branch (2586:32): [True: 0, False: 0]
|
2587 | 0 | if (view.HaveCoin(COutPoint(tx->GetHash(), o))) { Branch (2587:21): [True: 0, False: 0]
|
2588 | 0 | LogPrintf("ERROR: ConnectBlock(): tried to overwrite transaction\n"); |
2589 | 0 | return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-txns-BIP30"); |
2590 | 0 | } |
2591 | 0 | } |
2592 | 0 | } |
2593 | 0 | } |
2594 | | |
2595 | | // Enforce BIP68 (sequence locks) |
2596 | 0 | int nLockTimeFlags = 0; |
2597 | 0 | if (DeploymentActiveAt(*pindex, m_chainman, Consensus::DEPLOYMENT_CSV)) { Branch (2597:9): [True: 0, False: 0]
|
2598 | 0 | nLockTimeFlags |= LOCKTIME_VERIFY_SEQUENCE; |
2599 | 0 | } |
2600 | | |
2601 | | // Get the script flags for this block |
2602 | 0 | unsigned int flags{GetBlockScriptFlags(*pindex, m_chainman)}; |
2603 | |
|
2604 | 0 | const auto time_2{SteadyClock::now()}; |
2605 | 0 | m_chainman.time_forks += time_2 - time_1; |
2606 | 0 | LogPrint(BCLog::BENCH, " - Fork checks: %.2fms [%.2fs (%.2fms/blk)]\n", |
2607 | 0 | Ticks<MillisecondsDouble>(time_2 - time_1), |
2608 | 0 | Ticks<SecondsDouble>(m_chainman.time_forks), |
2609 | 0 | Ticks<MillisecondsDouble>(m_chainman.time_forks) / m_chainman.num_blocks_total); |
2610 | |
|
2611 | 0 | CBlockUndo blockundo; |
2612 | | |
2613 | | // Precomputed transaction data pointers must not be invalidated |
2614 | | // until after `control` has run the script checks (potentially |
2615 | | // in multiple threads). Preallocate the vector size so a new allocation |
2616 | | // doesn't invalidate pointers into the vector, and keep txsdata in scope |
2617 | | // for as long as `control`. |
2618 | 0 | CCheckQueueControl<CScriptCheck> control(fScriptChecks && parallel_script_checks ? &m_chainman.GetCheckQueue() : nullptr); Branch (2618:46): [True: 0, False: 0]
Branch (2618:63): [True: 0, False: 0]
|
2619 | 0 | std::vector<PrecomputedTransactionData> txsdata(block.vtx.size()); |
2620 | |
|
2621 | 0 | std::vector<int> prevheights; |
2622 | 0 | CAmount nFees = 0; |
2623 | 0 | int nInputs = 0; |
2624 | 0 | int64_t nSigOpsCost = 0; |
2625 | 0 | blockundo.vtxundo.reserve(block.vtx.size() - 1); |
2626 | 0 | for (unsigned int i = 0; i < block.vtx.size(); i++) Branch (2626:30): [True: 0, False: 0]
|
2627 | 0 | { |
2628 | 0 | const CTransaction &tx = *(block.vtx[i]); |
2629 | |
|
2630 | 0 | nInputs += tx.vin.size(); |
2631 | |
|
2632 | 0 | if (!tx.IsCoinBase()) Branch (2632:13): [True: 0, False: 0]
|
2633 | 0 | { |
2634 | 0 | CAmount txfee = 0; |
2635 | 0 | TxValidationState tx_state; |
2636 | 0 | if (!Consensus::CheckTxInputs(tx, tx_state, view, pindex->nHeight, txfee)) { Branch (2636:17): [True: 0, False: 0]
|
2637 | | // Any transaction validation failure in ConnectBlock is a block consensus failure |
2638 | 0 | state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, |
2639 | 0 | tx_state.GetRejectReason(), tx_state.GetDebugMessage()); |
2640 | 0 | LogError("%s: Consensus::CheckTxInputs: %s, %s\n", __func__, tx.GetHash().ToString(), state.ToString()); |
2641 | 0 | return false; |
2642 | 0 | } |
2643 | 0 | nFees += txfee; |
2644 | 0 | if (!MoneyRange(nFees)) { Branch (2644:17): [True: 0, False: 0]
|
2645 | 0 | LogPrintf("ERROR: %s: accumulated fee in the block out of range.\n", __func__); |
2646 | 0 | return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-txns-accumulated-fee-outofrange"); |
2647 | 0 | } |
2648 | | |
2649 | | // Check that transaction is BIP68 final |
2650 | | // BIP68 lock checks (as opposed to nLockTime checks) must |
2651 | | // be in ConnectBlock because they require the UTXO set |
2652 | 0 | prevheights.resize(tx.vin.size()); |
2653 | 0 | for (size_t j = 0; j < tx.vin.size(); j++) { Branch (2653:32): [True: 0, False: 0]
|
2654 | 0 | prevheights[j] = view.AccessCoin(tx.vin[j].prevout).nHeight; |
2655 | 0 | } |
2656 | |
|
2657 | 0 | if (!SequenceLocks(tx, nLockTimeFlags, prevheights, *pindex)) { Branch (2657:17): [True: 0, False: 0]
|
2658 | 0 | LogPrintf("ERROR: %s: contains a non-BIP68-final transaction\n", __func__); |
2659 | 0 | return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-txns-nonfinal"); |
2660 | 0 | } |
2661 | 0 | } |
2662 | | |
2663 | | // GetTransactionSigOpCost counts 3 types of sigops: |
2664 | | // * legacy (always) |
2665 | | // * p2sh (when P2SH enabled in flags and excludes coinbase) |
2666 | | // * witness (when witness enabled in flags and excludes coinbase) |
2667 | 0 | nSigOpsCost += GetTransactionSigOpCost(tx, view, flags); |
2668 | 0 | if (nSigOpsCost > MAX_BLOCK_SIGOPS_COST) { Branch (2668:13): [True: 0, False: 0]
|
2669 | 0 | LogPrintf("ERROR: ConnectBlock(): too many sigops\n"); |
2670 | 0 | return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-blk-sigops"); |
2671 | 0 | } |
2672 | | |
2673 | 0 | if (!tx.IsCoinBase()) Branch (2673:13): [True: 0, False: 0]
|
2674 | 0 | { |
2675 | 0 | std::vector<CScriptCheck> vChecks; |
2676 | 0 | bool fCacheResults = fJustCheck; /* Don't cache results if we're actually connecting blocks (still consult the cache, though) */ |
2677 | 0 | TxValidationState tx_state; |
2678 | 0 | if (fScriptChecks && !CheckInputScripts(tx, tx_state, view, flags, fCacheResults, fCacheResults, txsdata[i], m_chainman.m_validation_cache, parallel_script_checks ? &vChecks : nullptr)) { Branch (2678:17): [True: 0, False: 0]
Branch (2678:34): [True: 0, False: 0]
Branch (2678:153): [True: 0, False: 0]
|
2679 | | // Any transaction validation failure in ConnectBlock is a block consensus failure |
2680 | 0 | state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, |
2681 | 0 | tx_state.GetRejectReason(), tx_state.GetDebugMessage()); |
2682 | 0 | LogError("ConnectBlock(): CheckInputScripts on %s failed with %s\n", |
2683 | 0 | tx.GetHash().ToString(), state.ToString()); |
2684 | 0 | return false; |
2685 | 0 | } |
2686 | 0 | control.Add(std::move(vChecks)); |
2687 | 0 | } |
2688 | | |
2689 | 0 | CTxUndo undoDummy; |
2690 | 0 | if (i > 0) { Branch (2690:13): [True: 0, False: 0]
|
2691 | 0 | blockundo.vtxundo.emplace_back(); |
2692 | 0 | } |
2693 | 0 | UpdateCoins(tx, view, i == 0 ? undoDummy : blockundo.vtxundo.back(), pindex->nHeight); Branch (2693:31): [True: 0, False: 0]
|
2694 | 0 | } |
2695 | 0 | const auto time_3{SteadyClock::now()}; |
2696 | 0 | m_chainman.time_connect += time_3 - time_2; |
2697 | 0 | LogPrint(BCLog::BENCH, " - Connect %u transactions: %.2fms (%.3fms/tx, %.3fms/txin) [%.2fs (%.2fms/blk)]\n", (unsigned)block.vtx.size(), |
2698 | 0 | Ticks<MillisecondsDouble>(time_3 - time_2), Ticks<MillisecondsDouble>(time_3 - time_2) / block.vtx.size(), |
2699 | 0 | nInputs <= 1 ? 0 : Ticks<MillisecondsDouble>(time_3 - time_2) / (nInputs - 1), |
2700 | 0 | Ticks<SecondsDouble>(m_chainman.time_connect), |
2701 | 0 | Ticks<MillisecondsDouble>(m_chainman.time_connect) / m_chainman.num_blocks_total); |
2702 | |
|
2703 | 0 | CAmount blockReward = nFees + GetBlockSubsidy(pindex->nHeight, params.GetConsensus()); |
2704 | 0 | if (block.vtx[0]->GetValueOut() > blockReward) { Branch (2704:9): [True: 0, False: 0]
|
2705 | 0 | LogPrintf("ERROR: ConnectBlock(): coinbase pays too much (actual=%d vs limit=%d)\n", block.vtx[0]->GetValueOut(), blockReward); |
2706 | 0 | return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-cb-amount"); |
2707 | 0 | } |
2708 | | |
2709 | 0 | if (!control.Wait()) { Branch (2709:9): [True: 0, False: 0]
|
2710 | 0 | LogPrintf("ERROR: %s: CheckQueue failed\n", __func__); |
2711 | 0 | return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "block-validation-failed"); |
2712 | 0 | } |
2713 | 0 | const auto time_4{SteadyClock::now()}; |
2714 | 0 | m_chainman.time_verify += time_4 - time_2; |
2715 | 0 | LogPrint(BCLog::BENCH, " - Verify %u txins: %.2fms (%.3fms/txin) [%.2fs (%.2fms/blk)]\n", nInputs - 1, |
2716 | 0 | Ticks<MillisecondsDouble>(time_4 - time_2), |
2717 | 0 | nInputs <= 1 ? 0 : Ticks<MillisecondsDouble>(time_4 - time_2) / (nInputs - 1), |
2718 | 0 | Ticks<SecondsDouble>(m_chainman.time_verify), |
2719 | 0 | Ticks<MillisecondsDouble>(m_chainman.time_verify) / m_chainman.num_blocks_total); |
2720 | |
|
2721 | 0 | if (fJustCheck) Branch (2721:9): [True: 0, False: 0]
|
2722 | 0 | return true; |
2723 | | |
2724 | 0 | if (!m_blockman.WriteUndoDataForBlock(blockundo, state, *pindex)) { Branch (2724:9): [True: 0, False: 0]
|
2725 | 0 | return false; |
2726 | 0 | } |
2727 | | |
2728 | 0 | const auto time_5{SteadyClock::now()}; |
2729 | 0 | m_chainman.time_undo += time_5 - time_4; |
2730 | 0 | LogPrint(BCLog::BENCH, " - Write undo data: %.2fms [%.2fs (%.2fms/blk)]\n", |
2731 | 0 | Ticks<MillisecondsDouble>(time_5 - time_4), |
2732 | 0 | Ticks<SecondsDouble>(m_chainman.time_undo), |
2733 | 0 | Ticks<MillisecondsDouble>(m_chainman.time_undo) / m_chainman.num_blocks_total); |
2734 | |
|
2735 | 0 | if (!pindex->IsValid(BLOCK_VALID_SCRIPTS)) { Branch (2735:9): [True: 0, False: 0]
|
2736 | 0 | pindex->RaiseValidity(BLOCK_VALID_SCRIPTS); |
2737 | 0 | m_blockman.m_dirty_blockindex.insert(pindex); |
2738 | 0 | } |
2739 | | |
2740 | | // add this block to the view's block chain |
2741 | 0 | view.SetBestBlock(pindex->GetBlockHash()); |
2742 | |
|
2743 | 0 | const auto time_6{SteadyClock::now()}; |
2744 | 0 | m_chainman.time_index += time_6 - time_5; |
2745 | 0 | LogPrint(BCLog::BENCH, " - Index writing: %.2fms [%.2fs (%.2fms/blk)]\n", |
2746 | 0 | Ticks<MillisecondsDouble>(time_6 - time_5), |
2747 | 0 | Ticks<SecondsDouble>(m_chainman.time_index), |
2748 | 0 | Ticks<MillisecondsDouble>(m_chainman.time_index) / m_chainman.num_blocks_total); |
2749 | |
|
2750 | 0 | TRACE6(validation, block_connected, |
2751 | 0 | block_hash.data(), |
2752 | 0 | pindex->nHeight, |
2753 | 0 | block.vtx.size(), |
2754 | 0 | nInputs, |
2755 | 0 | nSigOpsCost, |
2756 | 0 | time_5 - time_start // in microseconds (µs) |
2757 | 0 | ); |
2758 | |
|
2759 | 0 | return true; |
2760 | 0 | } |
2761 | | |
2762 | | CoinsCacheSizeState Chainstate::GetCoinsCacheSizeState() |
2763 | 0 | { |
2764 | 0 | AssertLockHeld(::cs_main); |
2765 | 0 | return this->GetCoinsCacheSizeState( |
2766 | 0 | m_coinstip_cache_size_bytes, |
2767 | 0 | m_mempool ? m_mempool->m_opts.max_size_bytes : 0); Branch (2767:9): [True: 0, False: 0]
|
2768 | 0 | } |
2769 | | |
2770 | | CoinsCacheSizeState Chainstate::GetCoinsCacheSizeState( |
2771 | | size_t max_coins_cache_size_bytes, |
2772 | | size_t max_mempool_size_bytes) |
2773 | 0 | { |
2774 | 0 | AssertLockHeld(::cs_main); |
2775 | 0 | const int64_t nMempoolUsage = m_mempool ? m_mempool->DynamicMemoryUsage() : 0; Branch (2775:35): [True: 0, False: 0]
|
2776 | 0 | int64_t cacheSize = CoinsTip().DynamicMemoryUsage(); |
2777 | 0 | int64_t nTotalSpace = |
2778 | 0 | max_coins_cache_size_bytes + std::max<int64_t>(int64_t(max_mempool_size_bytes) - nMempoolUsage, 0); |
2779 | | |
2780 | | //! No need to periodic flush if at least this much space still available. |
2781 | 0 | static constexpr int64_t MAX_BLOCK_COINSDB_USAGE_BYTES = 10 * 1024 * 1024; // 10MB |
2782 | 0 | int64_t large_threshold = |
2783 | 0 | std::max((9 * nTotalSpace) / 10, nTotalSpace - MAX_BLOCK_COINSDB_USAGE_BYTES); |
2784 | |
|
2785 | 0 | if (cacheSize > nTotalSpace) { Branch (2785:9): [True: 0, False: 0]
|
2786 | 0 | LogPrintf("Cache size (%s) exceeds total space (%s)\n", cacheSize, nTotalSpace); |
2787 | 0 | return CoinsCacheSizeState::CRITICAL; |
2788 | 0 | } else if (cacheSize > large_threshold) { Branch (2788:16): [True: 0, False: 0]
|
2789 | 0 | return CoinsCacheSizeState::LARGE; |
2790 | 0 | } |
2791 | 0 | return CoinsCacheSizeState::OK; |
2792 | 0 | } |
2793 | | |
2794 | | bool Chainstate::FlushStateToDisk( |
2795 | | BlockValidationState &state, |
2796 | | FlushStateMode mode, |
2797 | | int nManualPruneHeight) |
2798 | 0 | { |
2799 | 0 | LOCK(cs_main); |
2800 | 0 | assert(this->CanFlushToDisk()); |
2801 | 0 | std::set<int> setFilesToPrune; |
2802 | 0 | bool full_flush_completed = false; |
2803 | |
|
2804 | 0 | const size_t coins_count = CoinsTip().GetCacheSize(); |
2805 | 0 | const size_t coins_mem_usage = CoinsTip().DynamicMemoryUsage(); |
2806 | |
|
2807 | 0 | try { |
2808 | 0 | { |
2809 | 0 | bool fFlushForPrune = false; |
2810 | 0 | bool fDoFullFlush = false; |
2811 | |
|
2812 | 0 | CoinsCacheSizeState cache_state = GetCoinsCacheSizeState(); |
2813 | 0 | LOCK(m_blockman.cs_LastBlockFile); |
2814 | 0 | if (m_blockman.IsPruneMode() && (m_blockman.m_check_for_pruning || nManualPruneHeight > 0) && m_chainman.m_blockman.m_blockfiles_indexed) { Branch (2814:13): [True: 0, False: 0]
Branch (2814:42): [True: 0, False: 0]
Branch (2814:76): [True: 0, False: 0]
Branch (2814:103): [True: 0, False: 0]
|
2815 | | // make sure we don't prune above any of the prune locks bestblocks |
2816 | | // pruning is height-based |
2817 | 0 | int last_prune{m_chain.Height()}; // last height we can prune |
2818 | 0 | std::optional<std::string> limiting_lock; // prune lock that actually was the limiting factor, only used for logging |
2819 | |
|
2820 | 0 | for (const auto& prune_lock : m_blockman.m_prune_locks) { Branch (2820:41): [True: 0, False: 0]
|
2821 | 0 | if (prune_lock.second.height_first == std::numeric_limits<int>::max()) continue; Branch (2821:21): [True: 0, False: 0]
|
2822 | | // Remove the buffer and one additional block here to get actual height that is outside of the buffer |
2823 | 0 | const int lock_height{prune_lock.second.height_first - PRUNE_LOCK_BUFFER - 1}; |
2824 | 0 | last_prune = std::max(1, std::min(last_prune, lock_height)); |
2825 | 0 | if (last_prune == lock_height) { Branch (2825:21): [True: 0, False: 0]
|
2826 | 0 | limiting_lock = prune_lock.first; |
2827 | 0 | } |
2828 | 0 | } |
2829 | |
|
2830 | 0 | if (limiting_lock) { Branch (2830:17): [True: 0, False: 0]
|
2831 | 0 | LogPrint(BCLog::PRUNE, "%s limited pruning to height %d\n", limiting_lock.value(), last_prune); |
2832 | 0 | } |
2833 | |
|
2834 | 0 | if (nManualPruneHeight > 0) { Branch (2834:17): [True: 0, False: 0]
|
2835 | 0 | LOG_TIME_MILLIS_WITH_CATEGORY("find files to prune (manual)", BCLog::BENCH); |
2836 | |
|
2837 | 0 | m_blockman.FindFilesToPruneManual( |
2838 | 0 | setFilesToPrune, |
2839 | 0 | std::min(last_prune, nManualPruneHeight), |
2840 | 0 | *this, m_chainman); |
2841 | 0 | } else { |
2842 | 0 | LOG_TIME_MILLIS_WITH_CATEGORY("find files to prune", BCLog::BENCH); |
2843 | |
|
2844 | 0 | m_blockman.FindFilesToPrune(setFilesToPrune, last_prune, *this, m_chainman); |
2845 | 0 | m_blockman.m_check_for_pruning = false; |
2846 | 0 | } |
2847 | 0 | if (!setFilesToPrune.empty()) { Branch (2847:17): [True: 0, False: 0]
|
2848 | 0 | fFlushForPrune = true; |
2849 | 0 | if (!m_blockman.m_have_pruned) { Branch (2849:21): [True: 0, False: 0]
|
2850 | 0 | m_blockman.m_block_tree_db->WriteFlag("prunedblockfiles", true); |
2851 | 0 | m_blockman.m_have_pruned = true; |
2852 | 0 | } |
2853 | 0 | } |
2854 | 0 | } |
2855 | 0 | const auto nNow{SteadyClock::now()}; |
2856 | | // Avoid writing/flushing immediately after startup. |
2857 | 0 | if (m_last_write == decltype(m_last_write){}) { Branch (2857:13): [True: 0, False: 0]
|
2858 | 0 | m_last_write = nNow; |
2859 | 0 | } |
2860 | 0 | if (m_last_flush == decltype(m_last_flush){}) { Branch (2860:13): [True: 0, False: 0]
|
2861 | 0 | m_last_flush = nNow; |
2862 | 0 | } |
2863 | | // 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). |
2864 | 0 | bool fCacheLarge = mode == FlushStateMode::PERIODIC && cache_state >= CoinsCacheSizeState::LARGE; Branch (2864:28): [True: 0, False: 0]
Branch (2864:64): [True: 0, False: 0]
|
2865 | | // The cache is over the limit, we have to write now. |
2866 | 0 | bool fCacheCritical = mode == FlushStateMode::IF_NEEDED && cache_state >= CoinsCacheSizeState::CRITICAL; Branch (2866:31): [True: 0, False: 0]
Branch (2866:68): [True: 0, False: 0]
|
2867 | | // 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. |
2868 | 0 | bool fPeriodicWrite = mode == FlushStateMode::PERIODIC && nNow > m_last_write + DATABASE_WRITE_INTERVAL; Branch (2868:31): [True: 0, False: 0]
Branch (2868:67): [True: 0, False: 0]
|
2869 | | // It's been very long since we flushed the cache. Do this infrequently, to optimize cache usage. |
2870 | 0 | bool fPeriodicFlush = mode == FlushStateMode::PERIODIC && nNow > m_last_flush + DATABASE_FLUSH_INTERVAL; Branch (2870:31): [True: 0, False: 0]
Branch (2870:67): [True: 0, False: 0]
|
2871 | | // Combine all conditions that result in a full cache flush. |
2872 | 0 | fDoFullFlush = (mode == FlushStateMode::ALWAYS) || fCacheLarge || fCacheCritical || fPeriodicFlush || fFlushForPrune; Branch (2872:24): [True: 0, False: 0]
Branch (2872:60): [True: 0, False: 0]
Branch (2872:75): [True: 0, False: 0]
Branch (2872:93): [True: 0, False: 0]
Branch (2872:111): [True: 0, False: 0]
|
2873 | | // Write blocks and block index to disk. |
2874 | 0 | if (fDoFullFlush || fPeriodicWrite) { Branch (2874:13): [True: 0, False: 0]
Branch (2874:29): [True: 0, False: 0]
|
2875 | | // Ensure we can write block index |
2876 | 0 | if (!CheckDiskSpace(m_blockman.m_opts.blocks_dir)) { Branch (2876:17): [True: 0, False: 0]
|
2877 | 0 | return FatalError(m_chainman.GetNotifications(), state, _("Disk space is too low!")); |
2878 | 0 | } |
2879 | 0 | { |
2880 | 0 | LOG_TIME_MILLIS_WITH_CATEGORY("write block and undo data to disk", BCLog::BENCH); |
2881 | | |
2882 | | // First make sure all block and undo data is flushed to disk. |
2883 | | // TODO: Handle return error, or add detailed comment why it is |
2884 | | // safe to not return an error upon failure. |
2885 | 0 | if (!m_blockman.FlushChainstateBlockFile(m_chain.Height())) { Branch (2885:21): [True: 0, False: 0]
|
2886 | 0 | LogPrintLevel(BCLog::VALIDATION, BCLog::Level::Warning, "%s: Failed to flush block file.\n", __func__); |
2887 | 0 | } |
2888 | 0 | } |
2889 | | |
2890 | | // Then update all block file information (which may refer to block and undo files). |
2891 | 0 | { |
2892 | 0 | LOG_TIME_MILLIS_WITH_CATEGORY("write block index to disk", BCLog::BENCH); |
2893 | |
|
2894 | 0 | if (!m_blockman.WriteBlockIndexDB()) { Branch (2894:21): [True: 0, False: 0]
|
2895 | 0 | return FatalError(m_chainman.GetNotifications(), state, _("Failed to write to block index database.")); |
2896 | 0 | } |
2897 | 0 | } |
2898 | | // Finally remove any pruned files |
2899 | 0 | if (fFlushForPrune) { Branch (2899:17): [True: 0, False: 0]
|
2900 | 0 | LOG_TIME_MILLIS_WITH_CATEGORY("unlink pruned files", BCLog::BENCH); |
2901 | |
|
2902 | 0 | m_blockman.UnlinkPrunedFiles(setFilesToPrune); |
2903 | 0 | } |
2904 | 0 | m_last_write = nNow; |
2905 | 0 | } |
2906 | | // Flush best chain related state. This can only be done if the blocks / block index write was also done. |
2907 | 0 | if (fDoFullFlush && !CoinsTip().GetBestBlock().IsNull()) { Branch (2907:13): [True: 0, False: 0]
Branch (2907:13): [True: 0, False: 0]
Branch (2907:29): [True: 0, False: 0]
|
2908 | 0 | LOG_TIME_MILLIS_WITH_CATEGORY(strprintf("write coins cache to disk (%d coins, %.2fkB)", |
2909 | 0 | coins_count, coins_mem_usage / 1000), BCLog::BENCH); |
2910 | | |
2911 | | // Typical Coin structures on disk are around 48 bytes in size. |
2912 | | // Pushing a new one to the database can cause it to be written |
2913 | | // twice (once in the log, and once in the tables). This is already |
2914 | | // an overestimation, as most will delete an existing entry or |
2915 | | // overwrite one. Still, use a conservative safety factor of 2. |
2916 | 0 | if (!CheckDiskSpace(m_chainman.m_options.datadir, 48 * 2 * 2 * CoinsTip().GetCacheSize())) { Branch (2916:17): [True: 0, False: 0]
|
2917 | 0 | return FatalError(m_chainman.GetNotifications(), state, _("Disk space is too low!")); |
2918 | 0 | } |
2919 | | // Flush the chainstate (which may refer to block index entries). |
2920 | 0 | const auto empty_cache{(mode == FlushStateMode::ALWAYS) || fCacheLarge || fCacheCritical}; Branch (2920:36): [True: 0, False: 0]
Branch (2920:72): [True: 0, False: 0]
Branch (2920:87): [True: 0, False: 0]
|
2921 | 0 | if (empty_cache ? !CoinsTip().Flush() : !CoinsTip().Sync()) { Branch (2921:17): [True: 0, False: 0]
Branch (2921:17): [True: 0, False: 0]
|
2922 | 0 | return FatalError(m_chainman.GetNotifications(), state, _("Failed to write to coin database.")); |
2923 | 0 | } |
2924 | 0 | m_last_flush = nNow; |
2925 | 0 | full_flush_completed = true; |
2926 | 0 | TRACE5(utxocache, flush, |
2927 | 0 | int64_t{Ticks<std::chrono::microseconds>(SteadyClock::now() - nNow)}, |
2928 | 0 | (uint32_t)mode, |
2929 | 0 | (uint64_t)coins_count, |
2930 | 0 | (uint64_t)coins_mem_usage, |
2931 | 0 | (bool)fFlushForPrune); |
2932 | 0 | } |
2933 | 0 | } |
2934 | 0 | if (full_flush_completed && m_chainman.m_options.signals) { Branch (2934:9): [True: 0, False: 0]
Branch (2934:33): [True: 0, False: 0]
|
2935 | | // Update best block in wallet (so we can detect restored wallets). |
2936 | 0 | m_chainman.m_options.signals->ChainStateFlushed(this->GetRole(), m_chain.GetLocator()); |
2937 | 0 | } |
2938 | 0 | } catch (const std::runtime_error& e) { |
2939 | 0 | return FatalError(m_chainman.GetNotifications(), state, strprintf(_("System error while flushing: %s"), e.what())); |
2940 | 0 | } |
2941 | 0 | return true; |
2942 | 0 | } |
2943 | | |
2944 | | void Chainstate::ForceFlushStateToDisk() |
2945 | 0 | { |
2946 | 0 | BlockValidationState state; |
2947 | 0 | if (!this->FlushStateToDisk(state, FlushStateMode::ALWAYS)) { Branch (2947:9): [True: 0, False: 0]
|
2948 | 0 | LogPrintf("%s: failed to flush state (%s)\n", __func__, state.ToString()); |
2949 | 0 | } |
2950 | 0 | } |
2951 | | |
2952 | | void Chainstate::PruneAndFlush() |
2953 | 0 | { |
2954 | 0 | BlockValidationState state; |
2955 | 0 | m_blockman.m_check_for_pruning = true; |
2956 | 0 | if (!this->FlushStateToDisk(state, FlushStateMode::NONE)) { Branch (2956:9): [True: 0, False: 0]
|
2957 | 0 | LogPrintf("%s: failed to flush state (%s)\n", __func__, state.ToString()); |
2958 | 0 | } |
2959 | 0 | } |
2960 | | |
2961 | | static void UpdateTipLog( |
2962 | | const CCoinsViewCache& coins_tip, |
2963 | | const CBlockIndex* tip, |
2964 | | const CChainParams& params, |
2965 | | const std::string& func_name, |
2966 | | const std::string& prefix, |
2967 | | const std::string& warning_messages) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) |
2968 | 0 | { |
2969 | |
|
2970 | 0 | AssertLockHeld(::cs_main); |
2971 | 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", |
2972 | 0 | prefix, func_name, |
2973 | 0 | tip->GetBlockHash().ToString(), tip->nHeight, tip->nVersion, |
2974 | 0 | log(tip->nChainWork.getdouble()) / log(2.0), tip->m_chain_tx_count, |
2975 | 0 | FormatISO8601DateTime(tip->GetBlockTime()), |
2976 | 0 | GuessVerificationProgress(params.TxData(), tip), |
2977 | 0 | coins_tip.DynamicMemoryUsage() * (1.0 / (1 << 20)), |
2978 | 0 | coins_tip.GetCacheSize(), |
2979 | 0 | !warning_messages.empty() ? strprintf(" warning='%s'", warning_messages) : ""); |
2980 | 0 | } |
2981 | | |
2982 | | void Chainstate::UpdateTip(const CBlockIndex* pindexNew) |
2983 | 0 | { |
2984 | 0 | AssertLockHeld(::cs_main); |
2985 | 0 | const auto& coins_tip = this->CoinsTip(); |
2986 | |
|
2987 | 0 | const CChainParams& params{m_chainman.GetParams()}; |
2988 | | |
2989 | | // The remainder of the function isn't relevant if we are not acting on |
2990 | | // the active chainstate, so return if need be. |
2991 | 0 | if (this != &m_chainman.ActiveChainstate()) { Branch (2991:9): [True: 0, False: 0]
|
2992 | | // Only log every so often so that we don't bury log messages at the tip. |
2993 | 0 | constexpr int BACKGROUND_LOG_INTERVAL = 2000; |
2994 | 0 | if (pindexNew->nHeight % BACKGROUND_LOG_INTERVAL == 0) { Branch (2994:13): [True: 0, False: 0]
|
2995 | 0 | UpdateTipLog(coins_tip, pindexNew, params, __func__, "[background validation] ", ""); |
2996 | 0 | } |
2997 | 0 | return; |
2998 | 0 | } |
2999 | | |
3000 | | // New best block |
3001 | 0 | if (m_mempool) { Branch (3001:9): [True: 0, False: 0]
|
3002 | 0 | m_mempool->AddTransactionsUpdated(1); |
3003 | 0 | } |
3004 | |
|
3005 | 0 | { |
3006 | 0 | LOCK(g_best_block_mutex); |
3007 | 0 | g_best_block = pindexNew->GetBlockHash(); |
3008 | 0 | g_best_block_cv.notify_all(); |
3009 | 0 | } |
3010 | |
|
3011 | 0 | std::vector<bilingual_str> warning_messages; |
3012 | 0 | if (!m_chainman.IsInitialBlockDownload()) { Branch (3012:9): [True: 0, False: 0]
|
3013 | 0 | const CBlockIndex* pindex = pindexNew; |
3014 | 0 | for (int bit = 0; bit < VERSIONBITS_NUM_BITS; bit++) { Branch (3014:27): [True: 0, False: 0]
|
3015 | 0 | WarningBitsConditionChecker checker(m_chainman, bit); |
3016 | 0 | ThresholdState state = checker.GetStateFor(pindex, params.GetConsensus(), m_chainman.m_warningcache.at(bit)); |
3017 | 0 | if (state == ThresholdState::ACTIVE || state == ThresholdState::LOCKED_IN) { Branch (3017:17): [True: 0, False: 0]
Branch (3017:52): [True: 0, False: 0]
|
3018 | 0 | const bilingual_str warning = strprintf(_("Unknown new rules activated (versionbit %i)"), bit); |
3019 | 0 | if (state == ThresholdState::ACTIVE) { Branch (3019:21): [True: 0, False: 0]
|
3020 | 0 | m_chainman.GetNotifications().warningSet(kernel::Warning::UNKNOWN_NEW_RULES_ACTIVATED, warning); |
3021 | 0 | } else { |
3022 | 0 | warning_messages.push_back(warning); |
3023 | 0 | } |
3024 | 0 | } |
3025 | 0 | } |
3026 | 0 | } |
3027 | 0 | UpdateTipLog(coins_tip, pindexNew, params, __func__, "", |
3028 | 0 | util::Join(warning_messages, Untranslated(", ")).original); |
3029 | 0 | } |
3030 | | |
3031 | | /** Disconnect m_chain's tip. |
3032 | | * After calling, the mempool will be in an inconsistent state, with |
3033 | | * transactions from disconnected blocks being added to disconnectpool. You |
3034 | | * should make the mempool consistent again by calling MaybeUpdateMempoolForReorg. |
3035 | | * with cs_main held. |
3036 | | * |
3037 | | * If disconnectpool is nullptr, then no disconnected transactions are added to |
3038 | | * disconnectpool (note that the caller is responsible for mempool consistency |
3039 | | * in any case). |
3040 | | */ |
3041 | | bool Chainstate::DisconnectTip(BlockValidationState& state, DisconnectedBlockTransactions* disconnectpool) |
3042 | 0 | { |
3043 | 0 | AssertLockHeld(cs_main); |
3044 | 0 | if (m_mempool) AssertLockHeld(m_mempool->cs); Branch (3044:9): [True: 0, False: 0]
|
3045 | |
|
3046 | 0 | CBlockIndex *pindexDelete = m_chain.Tip(); |
3047 | 0 | assert(pindexDelete); |
3048 | 0 | assert(pindexDelete->pprev); |
3049 | | // Read block from disk. |
3050 | 0 | std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>(); |
3051 | 0 | CBlock& block = *pblock; |
3052 | 0 | if (!m_blockman.ReadBlockFromDisk(block, *pindexDelete)) { Branch (3052:9): [True: 0, False: 0]
|
3053 | 0 | LogError("DisconnectTip(): Failed to read block\n"); |
3054 | 0 | return false; |
3055 | 0 | } |
3056 | | // Apply the block atomically to the chain state. |
3057 | 0 | const auto time_start{SteadyClock::now()}; |
3058 | 0 | { |
3059 | 0 | CCoinsViewCache view(&CoinsTip()); |
3060 | 0 | assert(view.GetBestBlock() == pindexDelete->GetBlockHash()); |
3061 | 0 | if (DisconnectBlock(block, pindexDelete, view) != DISCONNECT_OK) { Branch (3061:13): [True: 0, False: 0]
|
3062 | 0 | LogError("DisconnectTip(): DisconnectBlock %s failed\n", pindexDelete->GetBlockHash().ToString()); |
3063 | 0 | return false; |
3064 | 0 | } |
3065 | 0 | bool flushed = view.Flush(); |
3066 | 0 | assert(flushed); |
3067 | 0 | } |
3068 | 0 | LogPrint(BCLog::BENCH, "- Disconnect block: %.2fms\n", |
3069 | 0 | Ticks<MillisecondsDouble>(SteadyClock::now() - time_start)); |
3070 | |
|
3071 | 0 | { |
3072 | | // Prune locks that began at or after the tip should be moved backward so they get a chance to reorg |
3073 | 0 | const int max_height_first{pindexDelete->nHeight - 1}; |
3074 | 0 | for (auto& prune_lock : m_blockman.m_prune_locks) { Branch (3074:31): [True: 0, False: 0]
|
3075 | 0 | if (prune_lock.second.height_first <= max_height_first) continue; Branch (3075:17): [True: 0, False: 0]
|
3076 | | |
3077 | 0 | prune_lock.second.height_first = max_height_first; |
3078 | 0 | LogPrint(BCLog::PRUNE, "%s prune lock moved back to %d\n", prune_lock.first, max_height_first); |
3079 | 0 | } |
3080 | 0 | } |
3081 | | |
3082 | | // Write the chain state to disk, if necessary. |
3083 | 0 | if (!FlushStateToDisk(state, FlushStateMode::IF_NEEDED)) { Branch (3083:9): [True: 0, False: 0]
|
3084 | 0 | return false; |
3085 | 0 | } |
3086 | | |
3087 | 0 | if (disconnectpool && m_mempool) { Branch (3087:9): [True: 0, False: 0]
Branch (3087:27): [True: 0, False: 0]
|
3088 | | // Save transactions to re-add to mempool at end of reorg. If any entries are evicted for |
3089 | | // exceeding memory limits, remove them and their descendants from the mempool. |
3090 | 0 | for (auto&& evicted_tx : disconnectpool->AddTransactionsFromBlock(block.vtx)) { Branch (3090:32): [True: 0, False: 0]
|
3091 | 0 | m_mempool->removeRecursive(*evicted_tx, MemPoolRemovalReason::REORG); |
3092 | 0 | } |
3093 | 0 | } |
3094 | |
|
3095 | 0 | m_chain.SetTip(*pindexDelete->pprev); |
3096 | |
|
3097 | 0 | UpdateTip(pindexDelete->pprev); |
3098 | | // Let wallets know transactions went from 1-confirmed to |
3099 | | // 0-confirmed or conflicted: |
3100 | 0 | if (m_chainman.m_options.signals) { Branch (3100:9): [True: 0, False: 0]
|
3101 | 0 | m_chainman.m_options.signals->BlockDisconnected(pblock, pindexDelete); |
3102 | 0 | } |
3103 | 0 | return true; |
3104 | 0 | } |
3105 | | |
3106 | | struct PerBlockConnectTrace { |
3107 | | CBlockIndex* pindex = nullptr; |
3108 | | std::shared_ptr<const CBlock> pblock; |
3109 | 0 | PerBlockConnectTrace() = default; |
3110 | | }; |
3111 | | /** |
3112 | | * Used to track blocks whose transactions were applied to the UTXO state as a |
3113 | | * part of a single ActivateBestChainStep call. |
3114 | | * |
3115 | | * This class is single-use, once you call GetBlocksConnected() you have to throw |
3116 | | * it away and make a new one. |
3117 | | */ |
3118 | | class ConnectTrace { |
3119 | | private: |
3120 | | std::vector<PerBlockConnectTrace> blocksConnected; |
3121 | | |
3122 | | public: |
3123 | 0 | explicit ConnectTrace() : blocksConnected(1) {} |
3124 | | |
3125 | 0 | void BlockConnected(CBlockIndex* pindex, std::shared_ptr<const CBlock> pblock) { |
3126 | 0 | assert(!blocksConnected.back().pindex); |
3127 | 0 | assert(pindex); |
3128 | 0 | assert(pblock); |
3129 | 0 | blocksConnected.back().pindex = pindex; |
3130 | 0 | blocksConnected.back().pblock = std::move(pblock); |
3131 | 0 | blocksConnected.emplace_back(); |
3132 | 0 | } |
3133 | | |
3134 | 0 | std::vector<PerBlockConnectTrace>& GetBlocksConnected() { |
3135 | | // We always keep one extra block at the end of our list because |
3136 | | // blocks are added after all the conflicted transactions have |
3137 | | // been filled in. Thus, the last entry should always be an empty |
3138 | | // one waiting for the transactions from the next block. We pop |
3139 | | // the last entry here to make sure the list we return is sane. |
3140 | 0 | assert(!blocksConnected.back().pindex); |
3141 | 0 | blocksConnected.pop_back(); |
3142 | 0 | return blocksConnected; |
3143 | 0 | } |
3144 | | }; |
3145 | | |
3146 | | /** |
3147 | | * Connect a new block to m_chain. pblock is either nullptr or a pointer to a CBlock |
3148 | | * corresponding to pindexNew, to bypass loading it again from disk. |
3149 | | * |
3150 | | * The block is added to connectTrace if connection succeeds. |
3151 | | */ |
3152 | | bool Chainstate::ConnectTip(BlockValidationState& state, CBlockIndex* pindexNew, const std::shared_ptr<const CBlock>& pblock, ConnectTrace& connectTrace, DisconnectedBlockTransactions& disconnectpool) |
3153 | 0 | { |
3154 | 0 | AssertLockHeld(cs_main); |
3155 | 0 | if (m_mempool) AssertLockHeld(m_mempool->cs); Branch (3155:9): [True: 0, False: 0]
|
3156 | |
|
3157 | 0 | assert(pindexNew->pprev == m_chain.Tip()); |
3158 | | // Read block from disk. |
3159 | 0 | const auto time_1{SteadyClock::now()}; |
3160 | 0 | std::shared_ptr<const CBlock> pthisBlock; |
3161 | 0 | if (!pblock) { Branch (3161:9): [True: 0, False: 0]
|
3162 | 0 | std::shared_ptr<CBlock> pblockNew = std::make_shared<CBlock>(); |
3163 | 0 | if (!m_blockman.ReadBlockFromDisk(*pblockNew, *pindexNew)) { Branch (3163:13): [True: 0, False: 0]
|
3164 | 0 | return FatalError(m_chainman.GetNotifications(), state, _("Failed to read block.")); |
3165 | 0 | } |
3166 | 0 | pthisBlock = pblockNew; |
3167 | 0 | } else { |
3168 | 0 | LogPrint(BCLog::BENCH, " - Using cached block\n"); |
3169 | 0 | pthisBlock = pblock; |
3170 | 0 | } |
3171 | 0 | const CBlock& blockConnecting = *pthisBlock; |
3172 | | // Apply the block atomically to the chain state. |
3173 | 0 | const auto time_2{SteadyClock::now()}; |
3174 | 0 | SteadyClock::time_point time_3; |
3175 | | // When adding aggregate statistics in the future, keep in mind that |
3176 | | // num_blocks_total may be zero until the ConnectBlock() call below. |
3177 | 0 | LogPrint(BCLog::BENCH, " - Load block from disk: %.2fms\n", |
3178 | 0 | Ticks<MillisecondsDouble>(time_2 - time_1)); |
3179 | 0 | { |
3180 | 0 | CCoinsViewCache view(&CoinsTip()); |
3181 | 0 | bool rv = ConnectBlock(blockConnecting, state, pindexNew, view); |
3182 | 0 | if (m_chainman.m_options.signals) { Branch (3182:13): [True: 0, False: 0]
|
3183 | 0 | m_chainman.m_options.signals->BlockChecked(blockConnecting, state); |
3184 | 0 | } |
3185 | 0 | if (!rv) { Branch (3185:13): [True: 0, False: 0]
|
3186 | 0 | if (state.IsInvalid()) Branch (3186:17): [True: 0, False: 0]
|
3187 | 0 | InvalidBlockFound(pindexNew, state); |
3188 | 0 | LogError("%s: ConnectBlock %s failed, %s\n", __func__, pindexNew->GetBlockHash().ToString(), state.ToString()); |
3189 | 0 | return false; |
3190 | 0 | } |
3191 | 0 | time_3 = SteadyClock::now(); |
3192 | 0 | m_chainman.time_connect_total += time_3 - time_2; |
3193 | 0 | assert(m_chainman.num_blocks_total > 0); |
3194 | 0 | LogPrint(BCLog::BENCH, " - Connect total: %.2fms [%.2fs (%.2fms/blk)]\n", |
3195 | 0 | Ticks<MillisecondsDouble>(time_3 - time_2), |
3196 | 0 | Ticks<SecondsDouble>(m_chainman.time_connect_total), |
3197 | 0 | Ticks<MillisecondsDouble>(m_chainman.time_connect_total) / m_chainman.num_blocks_total); |
3198 | 0 | bool flushed = view.Flush(); |
3199 | 0 | assert(flushed); |
3200 | 0 | } |
3201 | 0 | const auto time_4{SteadyClock::now()}; |
3202 | 0 | m_chainman.time_flush += time_4 - time_3; |
3203 | 0 | LogPrint(BCLog::BENCH, " - Flush: %.2fms [%.2fs (%.2fms/blk)]\n", |
3204 | 0 | Ticks<MillisecondsDouble>(time_4 - time_3), |
3205 | 0 | Ticks<SecondsDouble>(m_chainman.time_flush), |
3206 | 0 | Ticks<MillisecondsDouble>(m_chainman.time_flush) / m_chainman.num_blocks_total); |
3207 | | // Write the chain state to disk, if necessary. |
3208 | 0 | if (!FlushStateToDisk(state, FlushStateMode::IF_NEEDED)) { Branch (3208:9): [True: 0, False: 0]
|
3209 | 0 | return false; |
3210 | 0 | } |
3211 | 0 | const auto time_5{SteadyClock::now()}; |
3212 | 0 | m_chainman.time_chainstate += time_5 - time_4; |
3213 | 0 | LogPrint(BCLog::BENCH, " - Writing chainstate: %.2fms [%.2fs (%.2fms/blk)]\n", |
3214 | 0 | Ticks<MillisecondsDouble>(time_5 - time_4), |
3215 | 0 | Ticks<SecondsDouble>(m_chainman.time_chainstate), |
3216 | 0 | Ticks<MillisecondsDouble>(m_chainman.time_chainstate) / m_chainman.num_blocks_total); |
3217 | | // Remove conflicting transactions from the mempool.; |
3218 | 0 | if (m_mempool) { Branch (3218:9): [True: 0, False: 0]
|
3219 | 0 | m_mempool->removeForBlock(blockConnecting.vtx, pindexNew->nHeight); |
3220 | 0 | disconnectpool.removeForBlock(blockConnecting.vtx); |
3221 | 0 | } |
3222 | | // Update m_chain & related variables. |
3223 | 0 | m_chain.SetTip(*pindexNew); |
3224 | 0 | UpdateTip(pindexNew); |
3225 | |
|
3226 | 0 | const auto time_6{SteadyClock::now()}; |
3227 | 0 | m_chainman.time_post_connect += time_6 - time_5; |
3228 | 0 | m_chainman.time_total += time_6 - time_1; |
3229 | 0 | LogPrint(BCLog::BENCH, " - Connect postprocess: %.2fms [%.2fs (%.2fms/blk)]\n", |
3230 | 0 | Ticks<MillisecondsDouble>(time_6 - time_5), |
3231 | 0 | Ticks<SecondsDouble>(m_chainman.time_post_connect), |
3232 | 0 | Ticks<MillisecondsDouble>(m_chainman.time_post_connect) / m_chainman.num_blocks_total); |
3233 | 0 | LogPrint(BCLog::BENCH, "- Connect block: %.2fms [%.2fs (%.2fms/blk)]\n", |
3234 | 0 | Ticks<MillisecondsDouble>(time_6 - time_1), |
3235 | 0 | Ticks<SecondsDouble>(m_chainman.time_total), |
3236 | 0 | Ticks<MillisecondsDouble>(m_chainman.time_total) / m_chainman.num_blocks_total); |
3237 | | |
3238 | | // If we are the background validation chainstate, check to see if we are done |
3239 | | // validating the snapshot (i.e. our tip has reached the snapshot's base block). |
3240 | 0 | if (this != &m_chainman.ActiveChainstate()) { Branch (3240:9): [True: 0, False: 0]
|
3241 | | // This call may set `m_disabled`, which is referenced immediately afterwards in |
3242 | | // ActivateBestChain, so that we stop connecting blocks past the snapshot base. |
3243 | 0 | m_chainman.MaybeCompleteSnapshotValidation(); |
3244 | 0 | } |
3245 | |
|
3246 | 0 | connectTrace.BlockConnected(pindexNew, std::move(pthisBlock)); |
3247 | 0 | return true; |
3248 | 0 | } |
3249 | | |
3250 | | /** |
3251 | | * Return the tip of the chain with the most work in it, that isn't |
3252 | | * known to be invalid (it's however far from certain to be valid). |
3253 | | */ |
3254 | | CBlockIndex* Chainstate::FindMostWorkChain() |
3255 | 0 | { |
3256 | 0 | AssertLockHeld(::cs_main); |
3257 | 0 | do { |
3258 | 0 | CBlockIndex *pindexNew = nullptr; |
3259 | | |
3260 | | // Find the best candidate header. |
3261 | 0 | { |
3262 | 0 | std::set<CBlockIndex*, CBlockIndexWorkComparator>::reverse_iterator it = setBlockIndexCandidates.rbegin(); |
3263 | 0 | if (it == setBlockIndexCandidates.rend()) Branch (3263:17): [True: 0, False: 0]
|
3264 | 0 | return nullptr; |
3265 | 0 | pindexNew = *it; |
3266 | 0 | } |
3267 | | |
3268 | | // Check whether all blocks on the path between the currently active chain and the candidate are valid. |
3269 | | // Just going until the active chain is an optimization, as we know all blocks in it are valid already. |
3270 | 0 | CBlockIndex *pindexTest = pindexNew; |
3271 | 0 | bool fInvalidAncestor = false; |
3272 | 0 | while (pindexTest && !m_chain.Contains(pindexTest)) { Branch (3272:16): [True: 0, False: 0]
Branch (3272:30): [True: 0, False: 0]
|
3273 | 0 | assert(pindexTest->HaveNumChainTxs() || pindexTest->nHeight == 0); |
3274 | | |
3275 | | // Pruned nodes may have entries in setBlockIndexCandidates for |
3276 | | // which block files have been deleted. Remove those as candidates |
3277 | | // for the most work chain if we come across them; we can't switch |
3278 | | // to a chain unless we have all the non-active-chain parent blocks. |
3279 | 0 | bool fFailedChain = pindexTest->nStatus & BLOCK_FAILED_MASK; |
3280 | 0 | bool fMissingData = !(pindexTest->nStatus & BLOCK_HAVE_DATA); |
3281 | 0 | if (fFailedChain || fMissingData) { Branch (3281:17): [True: 0, False: 0]
Branch (3281:33): [True: 0, False: 0]
|
3282 | | // Candidate chain is not usable (either invalid or missing data) |
3283 | 0 | if (fFailedChain && (m_chainman.m_best_invalid == nullptr || pindexNew->nChainWork > m_chainman.m_best_invalid->nChainWork)) { Branch (3283:21): [True: 0, False: 0]
Branch (3283:38): [True: 0, False: 0]
Branch (3283:78): [True: 0, False: 0]
|
3284 | 0 | m_chainman.m_best_invalid = pindexNew; |
3285 | 0 | } |
3286 | 0 | CBlockIndex *pindexFailed = pindexNew; |
3287 | | // Remove the entire chain from the set. |
3288 | 0 | while (pindexTest != pindexFailed) { Branch (3288:24): [True: 0, False: 0]
|
3289 | 0 | if (fFailedChain) { Branch (3289:25): [True: 0, False: 0]
|
3290 | 0 | pindexFailed->nStatus |= BLOCK_FAILED_CHILD; |
3291 | 0 | m_blockman.m_dirty_blockindex.insert(pindexFailed); |
3292 | 0 | } else if (fMissingData) { Branch (3292:32): [True: 0, False: 0]
|
3293 | | // If we're missing data, then add back to m_blocks_unlinked, |
3294 | | // so that if the block arrives in the future we can try adding |
3295 | | // to setBlockIndexCandidates again. |
3296 | 0 | m_blockman.m_blocks_unlinked.insert( |
3297 | 0 | std::make_pair(pindexFailed->pprev, pindexFailed)); |
3298 | 0 | } |
3299 | 0 | setBlockIndexCandidates.erase(pindexFailed); |
3300 | 0 | pindexFailed = pindexFailed->pprev; |
3301 | 0 | } |
3302 | 0 | setBlockIndexCandidates.erase(pindexTest); |
3303 | 0 | fInvalidAncestor = true; |
3304 | 0 | break; |
3305 | 0 | } |
3306 | 0 | pindexTest = pindexTest->pprev; |
3307 | 0 | } |
3308 | 0 | if (!fInvalidAncestor) Branch (3308:13): [True: 0, False: 0]
|
3309 | 0 | return pindexNew; |
3310 | 0 | } while(true); Branch (3310:13): [Folded - Ignored]
|
3311 | 0 | } |
3312 | | |
3313 | | /** Delete all entries in setBlockIndexCandidates that are worse than the current tip. */ |
3314 | 0 | void Chainstate::PruneBlockIndexCandidates() { |
3315 | | // Note that we can't delete the current block itself, as we may need to return to it later in case a |
3316 | | // reorganization to a better block fails. |
3317 | 0 | std::set<CBlockIndex*, CBlockIndexWorkComparator>::iterator it = setBlockIndexCandidates.begin(); |
3318 | 0 | while (it != setBlockIndexCandidates.end() && setBlockIndexCandidates.value_comp()(*it, m_chain.Tip())) { Branch (3318:12): [True: 0, False: 0]
Branch (3318:12): [True: 0, False: 0]
Branch (3318:51): [True: 0, False: 0]
|
3319 | 0 | setBlockIndexCandidates.erase(it++); |
3320 | 0 | } |
3321 | | // Either the current tip or a successor of it we're working towards is left in setBlockIndexCandidates. |
3322 | 0 | assert(!setBlockIndexCandidates.empty()); |
3323 | 0 | } |
3324 | | |
3325 | | /** |
3326 | | * Try to make some progress towards making pindexMostWork the active block. |
3327 | | * pblock is either nullptr or a pointer to a CBlock corresponding to pindexMostWork. |
3328 | | * |
3329 | | * @returns true unless a system error occurred |
3330 | | */ |
3331 | | bool Chainstate::ActivateBestChainStep(BlockValidationState& state, CBlockIndex* pindexMostWork, const std::shared_ptr<const CBlock>& pblock, bool& fInvalidFound, ConnectTrace& connectTrace) |
3332 | 0 | { |
3333 | 0 | AssertLockHeld(cs_main); |
3334 | 0 | if (m_mempool) AssertLockHeld(m_mempool->cs); Branch (3334:9): [True: 0, False: 0]
|
3335 | |
|
3336 | 0 | const CBlockIndex* pindexOldTip = m_chain.Tip(); |
3337 | 0 | const CBlockIndex* pindexFork = m_chain.FindFork(pindexMostWork); |
3338 | | |
3339 | | // Disconnect active blocks which are no longer in the best chain. |
3340 | 0 | bool fBlocksDisconnected = false; |
3341 | 0 | DisconnectedBlockTransactions disconnectpool{MAX_DISCONNECTED_TX_POOL_BYTES}; |
3342 | 0 | while (m_chain.Tip() && m_chain.Tip() != pindexFork) { Branch (3342:12): [True: 0, False: 0]
Branch (3342:29): [True: 0, False: 0]
|
3343 | 0 | if (!DisconnectTip(state, &disconnectpool)) { Branch (3343:13): [True: 0, False: 0]
|
3344 | | // This is likely a fatal error, but keep the mempool consistent, |
3345 | | // just in case. Only remove from the mempool in this case. |
3346 | 0 | MaybeUpdateMempoolForReorg(disconnectpool, false); |
3347 | | |
3348 | | // If we're unable to disconnect a block during normal operation, |
3349 | | // then that is a failure of our local system -- we should abort |
3350 | | // rather than stay on a less work chain. |
3351 | 0 | FatalError(m_chainman.GetNotifications(), state, _("Failed to disconnect block.")); |
3352 | 0 | return false; |
3353 | 0 | } |
3354 | 0 | fBlocksDisconnected = true; |
3355 | 0 | } |
3356 | | |
3357 | | // Build list of new blocks to connect (in descending height order). |
3358 | 0 | std::vector<CBlockIndex*> vpindexToConnect; |
3359 | 0 | bool fContinue = true; |
3360 | 0 | int nHeight = pindexFork ? pindexFork->nHeight : -1; Branch (3360:19): [True: 0, False: 0]
|
3361 | 0 | while (fContinue && nHeight != pindexMostWork->nHeight) { Branch (3361:12): [True: 0, False: 0]
Branch (3361:25): [True: 0, False: 0]
|
3362 | | // Don't iterate the entire list of potential improvements toward the best tip, as we likely only need |
3363 | | // a few blocks along the way. |
3364 | 0 | int nTargetHeight = std::min(nHeight + 32, pindexMostWork->nHeight); |
3365 | 0 | vpindexToConnect.clear(); |
3366 | 0 | vpindexToConnect.reserve(nTargetHeight - nHeight); |
3367 | 0 | CBlockIndex* pindexIter = pindexMostWork->GetAncestor(nTargetHeight); |
3368 | 0 | while (pindexIter && pindexIter->nHeight != nHeight) { Branch (3368:16): [True: 0, False: 0]
Branch (3368:30): [True: 0, False: 0]
|
3369 | 0 | vpindexToConnect.push_back(pindexIter); |
3370 | 0 | pindexIter = pindexIter->pprev; |
3371 | 0 | } |
3372 | 0 | nHeight = nTargetHeight; |
3373 | | |
3374 | | // Connect new blocks. |
3375 | 0 | for (CBlockIndex* pindexConnect : vpindexToConnect | std::views::reverse) { Branch (3375:41): [True: 0, False: 0]
|
3376 | 0 | if (!ConnectTip(state, pindexConnect, pindexConnect == pindexMostWork ? pblock : std::shared_ptr<const CBlock>(), connectTrace, disconnectpool)) { Branch (3376:17): [True: 0, False: 0]
Branch (3376:51): [True: 0, False: 0]
|
3377 | 0 | if (state.IsInvalid()) { Branch (3377:21): [True: 0, False: 0]
|
3378 | | // The block violates a consensus rule. |
3379 | 0 | if (state.GetResult() != BlockValidationResult::BLOCK_MUTATED) { Branch (3379:25): [True: 0, False: 0]
|
3380 | 0 | InvalidChainFound(vpindexToConnect.front()); |
3381 | 0 | } |
3382 | 0 | state = BlockValidationState(); |
3383 | 0 | fInvalidFound = true; |
3384 | 0 | fContinue = false; |
3385 | 0 | break; |
3386 | 0 | } else { |
3387 | | // A system error occurred (disk space, database error, ...). |
3388 | | // Make the mempool consistent with the current tip, just in case |
3389 | | // any observers try to use it before shutdown. |
3390 | 0 | MaybeUpdateMempoolForReorg(disconnectpool, false); |
3391 | 0 | return false; |
3392 | 0 | } |
3393 | 0 | } else { |
3394 | 0 | PruneBlockIndexCandidates(); |
3395 | 0 | if (!pindexOldTip || m_chain.Tip()->nChainWork > pindexOldTip->nChainWork) { Branch (3395:21): [True: 0, False: 0]
Branch (3395:38): [True: 0, False: 0]
|
3396 | | // We're in a better position than we were. Return temporarily to release the lock. |
3397 | 0 | fContinue = false; |
3398 | 0 | break; |
3399 | 0 | } |
3400 | 0 | } |
3401 | 0 | } |
3402 | 0 | } |
3403 | | |
3404 | 0 | if (fBlocksDisconnected) { Branch (3404:9): [True: 0, False: 0]
|
3405 | | // If any blocks were disconnected, disconnectpool may be non empty. Add |
3406 | | // any disconnected transactions back to the mempool. |
3407 | 0 | MaybeUpdateMempoolForReorg(disconnectpool, true); |
3408 | 0 | } |
3409 | 0 | if (m_mempool) m_mempool->check(this->CoinsTip(), this->m_chain.Height() + 1); Branch (3409:9): [True: 0, False: 0]
|
3410 | |
|
3411 | 0 | CheckForkWarningConditions(); |
3412 | |
|
3413 | 0 | return true; |
3414 | 0 | } |
3415 | | |
3416 | | static SynchronizationState GetSynchronizationState(bool init, bool blockfiles_indexed) |
3417 | 14 | { |
3418 | 14 | if (!init) return SynchronizationState::POST_INIT; Branch (3418:9): [True: 0, False: 14]
|
3419 | 14 | if (!blockfiles_indexed) return SynchronizationState::INIT_REINDEX; Branch (3419:9): [True: 0, False: 14]
|
3420 | 14 | return SynchronizationState::INIT_DOWNLOAD; |
3421 | 14 | } |
3422 | | |
3423 | | bool ChainstateManager::NotifyHeaderTip() |
3424 | 0 | { |
3425 | 0 | bool fNotify = false; |
3426 | 0 | bool fInitialBlockDownload = false; |
3427 | 0 | CBlockIndex* pindexHeader = nullptr; |
3428 | 0 | { |
3429 | 0 | LOCK(GetMutex()); |
3430 | 0 | pindexHeader = m_best_header; |
3431 | |
|
3432 | 0 | if (pindexHeader != m_last_notified_header) { Branch (3432:13): [True: 0, False: 0]
|
3433 | 0 | fNotify = true; |
3434 | 0 | fInitialBlockDownload = IsInitialBlockDownload(); |
3435 | 0 | m_last_notified_header = pindexHeader; |
3436 | 0 | } |
3437 | 0 | } |
3438 | | // Send block tip changed notifications without the lock held |
3439 | 0 | if (fNotify) { Branch (3439:9): [True: 0, False: 0]
|
3440 | 0 | GetNotifications().headerTip(GetSynchronizationState(fInitialBlockDownload, m_blockman.m_blockfiles_indexed), pindexHeader->nHeight, pindexHeader->nTime, false); |
3441 | 0 | } |
3442 | 0 | return fNotify; |
3443 | 0 | } |
3444 | | |
3445 | 0 | static void LimitValidationInterfaceQueue(ValidationSignals& signals) LOCKS_EXCLUDED(cs_main) { |
3446 | 0 | AssertLockNotHeld(cs_main); |
3447 | |
|
3448 | 0 | if (signals.CallbacksPending() > 10) { Branch (3448:9): [True: 0, False: 0]
|
3449 | 0 | signals.SyncWithValidationInterfaceQueue(); |
3450 | 0 | } |
3451 | 0 | } |
3452 | | |
3453 | | bool Chainstate::ActivateBestChain(BlockValidationState& state, std::shared_ptr<const CBlock> pblock) |
3454 | 0 | { |
3455 | 0 | AssertLockNotHeld(m_chainstate_mutex); |
3456 | | |
3457 | | // Note that while we're often called here from ProcessNewBlock, this is |
3458 | | // far from a guarantee. Things in the P2P/RPC will often end up calling |
3459 | | // us in the middle of ProcessNewBlock - do not assume pblock is set |
3460 | | // sanely for performance or correctness! |
3461 | 0 | AssertLockNotHeld(::cs_main); |
3462 | | |
3463 | | // ABC maintains a fair degree of expensive-to-calculate internal state |
3464 | | // because this function periodically releases cs_main so that it does not lock up other threads for too long |
3465 | | // during large connects - and to allow for e.g. the callback queue to drain |
3466 | | // we use m_chainstate_mutex to enforce mutual exclusion so that only one caller may execute this function at a time |
3467 | 0 | LOCK(m_chainstate_mutex); |
3468 | | |
3469 | | // Belt-and-suspenders check that we aren't attempting to advance the background |
3470 | | // chainstate past the snapshot base block. |
3471 | 0 | if (WITH_LOCK(::cs_main, return m_disabled)) { |
3472 | 0 | LogPrintf("m_disabled is set - this chainstate should not be in operation. " |
3473 | 0 | "Please report this as a bug. %s\n", PACKAGE_BUGREPORT); |
3474 | 0 | return false; |
3475 | 0 | } |
3476 | | |
3477 | 0 | CBlockIndex *pindexMostWork = nullptr; |
3478 | 0 | CBlockIndex *pindexNewTip = nullptr; |
3479 | 0 | bool exited_ibd{false}; |
3480 | 0 | do { |
3481 | | // Block until the validation queue drains. This should largely |
3482 | | // never happen in normal operation, however may happen during |
3483 | | // reindex, causing memory blowup if we run too far ahead. |
3484 | | // Note that if a validationinterface callback ends up calling |
3485 | | // ActivateBestChain this may lead to a deadlock! We should |
3486 | | // probably have a DEBUG_LOCKORDER test for this in the future. |
3487 | 0 | if (m_chainman.m_options.signals) LimitValidationInterfaceQueue(*m_chainman.m_options.signals); Branch (3487:13): [True: 0, False: 0]
|
3488 | |
|
3489 | 0 | { |
3490 | 0 | LOCK(cs_main); |
3491 | 0 | { |
3492 | | // Lock transaction pool for at least as long as it takes for connectTrace to be consumed |
3493 | 0 | LOCK(MempoolMutex()); |
3494 | 0 | const bool was_in_ibd = m_chainman.IsInitialBlockDownload(); |
3495 | 0 | CBlockIndex* starting_tip = m_chain.Tip(); |
3496 | 0 | bool blocks_connected = false; |
3497 | 0 | do { |
3498 | | // We absolutely may not unlock cs_main until we've made forward progress |
3499 | | // (with the exception of shutdown due to hardware issues, low disk space, etc). |
3500 | 0 | ConnectTrace connectTrace; // Destructed before cs_main is unlocked |
3501 | |
|
3502 | 0 | if (pindexMostWork == nullptr) { Branch (3502:21): [True: 0, False: 0]
|
3503 | 0 | pindexMostWork = FindMostWorkChain(); |
3504 | 0 | } |
3505 | | |
3506 | | // Whether we have anything to do at all. |
3507 | 0 | if (pindexMostWork == nullptr || pindexMostWork == m_chain.Tip()) { Branch (3507:21): [True: 0, False: 0]
Branch (3507:50): [True: 0, False: 0]
|
3508 | 0 | break; |
3509 | 0 | } |
3510 | | |
3511 | 0 | bool fInvalidFound = false; |
3512 | 0 | std::shared_ptr<const CBlock> nullBlockPtr; |
3513 | 0 | if (!ActivateBestChainStep(state, pindexMostWork, pblock && pblock->GetHash() == pindexMostWork->GetBlockHash() ? pblock : nullBlockPtr, fInvalidFound, connectTrace)) { Branch (3513:21): [True: 0, False: 0]
Branch (3513:67): [True: 0, False: 0]
Branch (3513:77): [True: 0, False: 0]
|
3514 | | // A system error occurred |
3515 | 0 | return false; |
3516 | 0 | } |
3517 | 0 | blocks_connected = true; |
3518 | |
|
3519 | 0 | if (fInvalidFound) { Branch (3519:21): [True: 0, False: 0]
|
3520 | | // Wipe cache, we may need another branch now. |
3521 | 0 | pindexMostWork = nullptr; |
3522 | 0 | } |
3523 | 0 | pindexNewTip = m_chain.Tip(); |
3524 | |
|
3525 | 0 | for (const PerBlockConnectTrace& trace : connectTrace.GetBlocksConnected()) { Branch (3525:56): [True: 0, False: 0]
|
3526 | 0 | assert(trace.pblock && trace.pindex); |
3527 | 0 | if (m_chainman.m_options.signals) { Branch (3527:25): [True: 0, False: 0]
|
3528 | 0 | m_chainman.m_options.signals->BlockConnected(this->GetRole(), trace.pblock, trace.pindex); |
3529 | 0 | } |
3530 | 0 | } |
3531 | | |
3532 | | // This will have been toggled in |
3533 | | // ActivateBestChainStep -> ConnectTip -> MaybeCompleteSnapshotValidation, |
3534 | | // if at all, so we should catch it here. |
3535 | | // |
3536 | | // Break this do-while to ensure we don't advance past the base snapshot. |
3537 | 0 | if (m_disabled) { Branch (3537:21): [True: 0, False: 0]
|
3538 | 0 | break; |
3539 | 0 | } |
3540 | 0 | } while (!m_chain.Tip() || (starting_tip && CBlockIndexWorkComparator()(m_chain.Tip(), starting_tip))); Branch (3540:22): [True: 0, False: 0]
Branch (3540:22): [True: 0, False: 0]
Branch (3540:41): [True: 0, False: 0]
Branch (3540:57): [True: 0, False: 0]
|
3541 | 0 | if (!blocks_connected) return true; Branch (3541:17): [True: 0, False: 0]
|
3542 | | |
3543 | 0 | const CBlockIndex* pindexFork = m_chain.FindFork(starting_tip); |
3544 | 0 | bool still_in_ibd = m_chainman.IsInitialBlockDownload(); |
3545 | |
|
3546 | 0 | if (was_in_ibd && !still_in_ibd) { Branch (3546:17): [True: 0, False: 0]
Branch (3546:31): [True: 0, False: 0]
|
3547 | | // Active chainstate has exited IBD. |
3548 | 0 | exited_ibd = true; |
3549 | 0 | } |
3550 | | |
3551 | | // Notify external listeners about the new tip. |
3552 | | // Enqueue while holding cs_main to ensure that UpdatedBlockTip is called in the order in which blocks are connected |
3553 | 0 | if (this == &m_chainman.ActiveChainstate() && pindexFork != pindexNewTip) { Branch (3553:17): [True: 0, False: 0]
Branch (3553:59): [True: 0, False: 0]
|
3554 | | // Notify ValidationInterface subscribers |
3555 | 0 | if (m_chainman.m_options.signals) { Branch (3555:21): [True: 0, False: 0]
|
3556 | 0 | m_chainman.m_options.signals->UpdatedBlockTip(pindexNewTip, pindexFork, still_in_ibd); |
3557 | 0 | } |
3558 | | |
3559 | | // Always notify the UI if a new block tip was connected |
3560 | 0 | if (kernel::IsInterrupted(m_chainman.GetNotifications().blockTip(GetSynchronizationState(still_in_ibd, m_chainman.m_blockman.m_blockfiles_indexed), *pindexNewTip))) { Branch (3560:21): [True: 0, False: 0]
|
3561 | | // Just breaking and returning success for now. This could |
3562 | | // be changed to bubble up the kernel::Interrupted value to |
3563 | | // the caller so the caller could distinguish between |
3564 | | // completed and interrupted operations. |
3565 | 0 | break; |
3566 | 0 | } |
3567 | 0 | } |
3568 | 0 | } // release MempoolMutex |
3569 | | // Notify external listeners about the new tip, even if pindexFork == pindexNewTip. |
3570 | 0 | if (m_chainman.m_options.signals && this == &m_chainman.ActiveChainstate()) { Branch (3570:17): [True: 0, False: 0]
Branch (3570:49): [True: 0, False: 0]
|
3571 | 0 | m_chainman.m_options.signals->ActiveTipChange(*Assert(pindexNewTip), m_chainman.IsInitialBlockDownload()); |
3572 | 0 | } |
3573 | 0 | } // release cs_main |
3574 | | // When we reach this point, we switched to a new tip (stored in pindexNewTip). |
3575 | | |
3576 | 0 | if (exited_ibd) { Branch (3576:13): [True: 0, False: 0]
|
3577 | | // If a background chainstate is in use, we may need to rebalance our |
3578 | | // allocation of caches once a chainstate exits initial block download. |
3579 | 0 | LOCK(::cs_main); |
3580 | 0 | m_chainman.MaybeRebalanceCaches(); |
3581 | 0 | } |
3582 | |
|
3583 | 0 | if (WITH_LOCK(::cs_main, return m_disabled)) { |
3584 | | // Background chainstate has reached the snapshot base block, so exit. |
3585 | | |
3586 | | // Restart indexes to resume indexing for all blocks unique to the snapshot |
3587 | | // chain. This resumes indexing "in order" from where the indexing on the |
3588 | | // background validation chain left off. |
3589 | | // |
3590 | | // This cannot be done while holding cs_main (within |
3591 | | // MaybeCompleteSnapshotValidation) or a cs_main deadlock will occur. |
3592 | 0 | if (m_chainman.restart_indexes) { Branch (3592:17): [True: 0, False: 0]
|
3593 | 0 | m_chainman.restart_indexes(); |
3594 | 0 | } |
3595 | 0 | break; |
3596 | 0 | } |
3597 | | |
3598 | | // We check interrupt only after giving ActivateBestChainStep a chance to run once so that we |
3599 | | // never interrupt before connecting the genesis block during LoadChainTip(). Previously this |
3600 | | // caused an assert() failure during interrupt in such cases as the UTXO DB flushing checks |
3601 | | // that the best block hash is non-null. |
3602 | 0 | if (m_chainman.m_interrupt) break; Branch (3602:13): [True: 0, False: 0]
|
3603 | 0 | } while (pindexNewTip != pindexMostWork); Branch (3603:14): [True: 0, False: 0]
|
3604 | | |
3605 | 0 | m_chainman.CheckBlockIndex(); |
3606 | | |
3607 | | // Write changes periodically to disk, after relay. |
3608 | 0 | if (!FlushStateToDisk(state, FlushStateMode::PERIODIC)) { Branch (3608:9): [True: 0, False: 0]
|
3609 | 0 | return false; |
3610 | 0 | } |
3611 | | |
3612 | 0 | return true; |
3613 | 0 | } |
3614 | | |
3615 | | bool Chainstate::PreciousBlock(BlockValidationState& state, CBlockIndex* pindex) |
3616 | 0 | { |
3617 | 0 | AssertLockNotHeld(m_chainstate_mutex); |
3618 | 0 | AssertLockNotHeld(::cs_main); |
3619 | 0 | { |
3620 | 0 | LOCK(cs_main); |
3621 | 0 | if (pindex->nChainWork < m_chain.Tip()->nChainWork) { Branch (3621:13): [True: 0, False: 0]
|
3622 | | // Nothing to do, this block is not at the tip. |
3623 | 0 | return true; |
3624 | 0 | } |
3625 | 0 | if (m_chain.Tip()->nChainWork > m_chainman.nLastPreciousChainwork) { Branch (3625:13): [True: 0, False: 0]
|
3626 | | // The chain has been extended since the last call, reset the counter. |
3627 | 0 | m_chainman.nBlockReverseSequenceId = -1; |
3628 | 0 | } |
3629 | 0 | m_chainman.nLastPreciousChainwork = m_chain.Tip()->nChainWork; |
3630 | 0 | setBlockIndexCandidates.erase(pindex); |
3631 | 0 | pindex->nSequenceId = m_chainman.nBlockReverseSequenceId; |
3632 | 0 | if (m_chainman.nBlockReverseSequenceId > std::numeric_limits<int32_t>::min()) { Branch (3632:13): [True: 0, False: 0]
|
3633 | | // We can't keep reducing the counter if somebody really wants to |
3634 | | // call preciousblock 2**31-1 times on the same set of tips... |
3635 | 0 | m_chainman.nBlockReverseSequenceId--; |
3636 | 0 | } |
3637 | 0 | if (pindex->IsValid(BLOCK_VALID_TRANSACTIONS) && pindex->HaveNumChainTxs()) { Branch (3637:13): [True: 0, False: 0]
Branch (3637:58): [True: 0, False: 0]
|
3638 | 0 | setBlockIndexCandidates.insert(pindex); |
3639 | 0 | PruneBlockIndexCandidates(); |
3640 | 0 | } |
3641 | 0 | } |
3642 | | |
3643 | 0 | return ActivateBestChain(state, std::shared_ptr<const CBlock>()); |
3644 | 0 | } |
3645 | | |
3646 | | bool Chainstate::InvalidateBlock(BlockValidationState& state, CBlockIndex* pindex) |
3647 | 0 | { |
3648 | 0 | AssertLockNotHeld(m_chainstate_mutex); |
3649 | 0 | AssertLockNotHeld(::cs_main); |
3650 | | |
3651 | | // Genesis block can't be invalidated |
3652 | 0 | assert(pindex); |
3653 | 0 | if (pindex->nHeight == 0) return false; Branch (3653:9): [True: 0, False: 0]
|
3654 | | |
3655 | 0 | CBlockIndex* to_mark_failed = pindex; |
3656 | 0 | bool pindex_was_in_chain = false; |
3657 | 0 | int disconnected = 0; |
3658 | | |
3659 | | // We do not allow ActivateBestChain() to run while InvalidateBlock() is |
3660 | | // running, as that could cause the tip to change while we disconnect |
3661 | | // blocks. |
3662 | 0 | LOCK(m_chainstate_mutex); |
3663 | | |
3664 | | // We'll be acquiring and releasing cs_main below, to allow the validation |
3665 | | // callbacks to run. However, we should keep the block index in a |
3666 | | // consistent state as we disconnect blocks -- in particular we need to |
3667 | | // add equal-work blocks to setBlockIndexCandidates as we disconnect. |
3668 | | // To avoid walking the block index repeatedly in search of candidates, |
3669 | | // build a map once so that we can look up candidate blocks by chain |
3670 | | // work as we go. |
3671 | 0 | std::multimap<const arith_uint256, CBlockIndex *> candidate_blocks_by_work; |
3672 | |
|
3673 | 0 | { |
3674 | 0 | LOCK(cs_main); |
3675 | 0 | for (auto& entry : m_blockman.m_block_index) { Branch (3675:26): [True: 0, False: 0]
|
3676 | 0 | CBlockIndex* candidate = &entry.second; |
3677 | | // We don't need to put anything in our active chain into the |
3678 | | // multimap, because those candidates will be found and considered |
3679 | | // as we disconnect. |
3680 | | // Instead, consider only non-active-chain blocks that have at |
3681 | | // least as much work as where we expect the new tip to end up. |
3682 | 0 | if (!m_chain.Contains(candidate) && Branch (3682:17): [True: 0, False: 0]
Branch (3682:17): [True: 0, False: 0]
|
3683 | 0 | !CBlockIndexWorkComparator()(candidate, pindex->pprev) && Branch (3683:21): [True: 0, False: 0]
|
3684 | 0 | candidate->IsValid(BLOCK_VALID_TRANSACTIONS) && Branch (3684:21): [True: 0, False: 0]
|
3685 | 0 | candidate->HaveNumChainTxs()) { Branch (3685:21): [True: 0, False: 0]
|
3686 | 0 | candidate_blocks_by_work.insert(std::make_pair(candidate->nChainWork, candidate)); |
3687 | 0 | } |
3688 | 0 | } |
3689 | 0 | } |
3690 | | |
3691 | | // Disconnect (descendants of) pindex, and mark them invalid. |
3692 | 0 | while (true) { Branch (3692:12): [Folded - Ignored]
|
3693 | 0 | if (m_chainman.m_interrupt) break; Branch (3693:13): [True: 0, False: 0]
|
3694 | | |
3695 | | // Make sure the queue of validation callbacks doesn't grow unboundedly. |
3696 | 0 | if (m_chainman.m_options.signals) LimitValidationInterfaceQueue(*m_chainman.m_options.signals); Branch (3696:13): [True: 0, False: 0]
|
3697 | |
|
3698 | 0 | LOCK(cs_main); |
3699 | | // Lock for as long as disconnectpool is in scope to make sure MaybeUpdateMempoolForReorg is |
3700 | | // called after DisconnectTip without unlocking in between |
3701 | 0 | LOCK(MempoolMutex()); |
3702 | 0 | if (!m_chain.Contains(pindex)) break; Branch (3702:13): [True: 0, False: 0]
|
3703 | 0 | pindex_was_in_chain = true; |
3704 | 0 | CBlockIndex *invalid_walk_tip = m_chain.Tip(); |
3705 | | |
3706 | | // ActivateBestChain considers blocks already in m_chain |
3707 | | // unconditionally valid already, so force disconnect away from it. |
3708 | 0 | DisconnectedBlockTransactions disconnectpool{MAX_DISCONNECTED_TX_POOL_BYTES}; |
3709 | 0 | bool ret = DisconnectTip(state, &disconnectpool); |
3710 | | // DisconnectTip will add transactions to disconnectpool. |
3711 | | // Adjust the mempool to be consistent with the new tip, adding |
3712 | | // transactions back to the mempool if disconnecting was successful, |
3713 | | // and we're not doing a very deep invalidation (in which case |
3714 | | // keeping the mempool up to date is probably futile anyway). |
3715 | 0 | MaybeUpdateMempoolForReorg(disconnectpool, /* fAddToMempool = */ (++disconnected <= 10) && ret); Branch (3715:74): [True: 0, False: 0]
Branch (3715:100): [True: 0, False: 0]
|
3716 | 0 | if (!ret) return false; Branch (3716:13): [True: 0, False: 0]
|
3717 | 0 | assert(invalid_walk_tip->pprev == m_chain.Tip()); |
3718 | | |
3719 | | // We immediately mark the disconnected blocks as invalid. |
3720 | | // This prevents a case where pruned nodes may fail to invalidateblock |
3721 | | // and be left unable to start as they have no tip candidates (as there |
3722 | | // are no blocks that meet the "have data and are not invalid per |
3723 | | // nStatus" criteria for inclusion in setBlockIndexCandidates). |
3724 | 0 | invalid_walk_tip->nStatus |= BLOCK_FAILED_VALID; |
3725 | 0 | m_blockman.m_dirty_blockindex.insert(invalid_walk_tip); |
3726 | 0 | setBlockIndexCandidates.erase(invalid_walk_tip); |
3727 | 0 | setBlockIndexCandidates.insert(invalid_walk_tip->pprev); |
3728 | 0 | if (invalid_walk_tip->pprev == to_mark_failed && (to_mark_failed->nStatus & BLOCK_FAILED_VALID)) { Branch (3728:13): [True: 0, False: 0]
Branch (3728:58): [True: 0, False: 0]
|
3729 | | // We only want to mark the last disconnected block as BLOCK_FAILED_VALID; its children |
3730 | | // need to be BLOCK_FAILED_CHILD instead. |
3731 | 0 | to_mark_failed->nStatus = (to_mark_failed->nStatus ^ BLOCK_FAILED_VALID) | BLOCK_FAILED_CHILD; |
3732 | 0 | m_blockman.m_dirty_blockindex.insert(to_mark_failed); |
3733 | 0 | } |
3734 | | |
3735 | | // Add any equal or more work headers to setBlockIndexCandidates |
3736 | 0 | auto candidate_it = candidate_blocks_by_work.lower_bound(invalid_walk_tip->pprev->nChainWork); |
3737 | 0 | while (candidate_it != candidate_blocks_by_work.end()) { Branch (3737:16): [True: 0, False: 0]
|
3738 | 0 | if (!CBlockIndexWorkComparator()(candidate_it->second, invalid_walk_tip->pprev)) { Branch (3738:17): [True: 0, False: 0]
|
3739 | 0 | setBlockIndexCandidates.insert(candidate_it->second); |
3740 | 0 | candidate_it = candidate_blocks_by_work.erase(candidate_it); |
3741 | 0 | } else { |
3742 | 0 | ++candidate_it; |
3743 | 0 | } |
3744 | 0 | } |
3745 | | |
3746 | | // Track the last disconnected block, so we can correct its BLOCK_FAILED_CHILD status in future |
3747 | | // iterations, or, if it's the last one, call InvalidChainFound on it. |
3748 | 0 | to_mark_failed = invalid_walk_tip; |
3749 | 0 | } |
3750 | | |
3751 | 0 | m_chainman.CheckBlockIndex(); |
3752 | |
|
3753 | 0 | { |
3754 | 0 | LOCK(cs_main); |
3755 | 0 | if (m_chain.Contains(to_mark_failed)) { Branch (3755:13): [True: 0, False: 0]
|
3756 | | // If the to-be-marked invalid block is in the active chain, something is interfering and we can't proceed. |
3757 | 0 | return false; |
3758 | 0 | } |
3759 | | |
3760 | | // Mark pindex (or the last disconnected block) as invalid, even when it never was in the main chain |
3761 | 0 | to_mark_failed->nStatus |= BLOCK_FAILED_VALID; |
3762 | 0 | m_blockman.m_dirty_blockindex.insert(to_mark_failed); |
3763 | 0 | setBlockIndexCandidates.erase(to_mark_failed); |
3764 | 0 | m_chainman.m_failed_blocks.insert(to_mark_failed); |
3765 | | |
3766 | | // If any new blocks somehow arrived while we were disconnecting |
3767 | | // (above), then the pre-calculation of what should go into |
3768 | | // setBlockIndexCandidates may have missed entries. This would |
3769 | | // technically be an inconsistency in the block index, but if we clean |
3770 | | // it up here, this should be an essentially unobservable error. |
3771 | | // Loop back over all block index entries and add any missing entries |
3772 | | // to setBlockIndexCandidates. |
3773 | 0 | for (auto& [_, block_index] : m_blockman.m_block_index) { Branch (3773:37): [True: 0, False: 0]
|
3774 | 0 | if (block_index.IsValid(BLOCK_VALID_TRANSACTIONS) && block_index.HaveNumChainTxs() && !setBlockIndexCandidates.value_comp()(&block_index, m_chain.Tip())) { Branch (3774:17): [True: 0, False: 0]
Branch (3774:17): [True: 0, False: 0]
Branch (3774:66): [True: 0, False: 0]
Branch (3774:99): [True: 0, False: 0]
|
3775 | 0 | setBlockIndexCandidates.insert(&block_index); |
3776 | 0 | } |
3777 | 0 | } |
3778 | |
|
3779 | 0 | InvalidChainFound(to_mark_failed); |
3780 | 0 | } |
3781 | | |
3782 | | // Only notify about a new block tip if the active chain was modified. |
3783 | 0 | if (pindex_was_in_chain) { Branch (3783:9): [True: 0, False: 0]
|
3784 | | // Ignoring return value for now, this could be changed to bubble up |
3785 | | // kernel::Interrupted value to the caller so the caller could |
3786 | | // distinguish between completed and interrupted operations. It might |
3787 | | // also make sense for the blockTip notification to have an enum |
3788 | | // parameter indicating the source of the tip change so hooks can |
3789 | | // distinguish user-initiated invalidateblock changes from other |
3790 | | // changes. |
3791 | 0 | (void)m_chainman.GetNotifications().blockTip(GetSynchronizationState(m_chainman.IsInitialBlockDownload(), m_chainman.m_blockman.m_blockfiles_indexed), *to_mark_failed->pprev); |
3792 | | |
3793 | | // Fire ActiveTipChange now for the current chain tip to make sure clients are notified. |
3794 | | // ActivateBestChain may call this as well, but not necessarily. |
3795 | 0 | if (m_chainman.m_options.signals) { Branch (3795:13): [True: 0, False: 0]
|
3796 | 0 | m_chainman.m_options.signals->ActiveTipChange(*Assert(m_chain.Tip()), m_chainman.IsInitialBlockDownload()); |
3797 | 0 | } |
3798 | 0 | } |
3799 | 0 | return true; |
3800 | 0 | } |
3801 | | |
3802 | 0 | void Chainstate::ResetBlockFailureFlags(CBlockIndex *pindex) { |
3803 | 0 | AssertLockHeld(cs_main); |
3804 | |
|
3805 | 0 | int nHeight = pindex->nHeight; |
3806 | | |
3807 | | // Remove the invalidity flag from this block and all its descendants. |
3808 | 0 | for (auto& [_, block_index] : m_blockman.m_block_index) { Branch (3808:33): [True: 0, False: 0]
|
3809 | 0 | if (!block_index.IsValid() && block_index.GetAncestor(nHeight) == pindex) { Branch (3809:13): [True: 0, False: 0]
Branch (3809:39): [True: 0, False: 0]
|
3810 | 0 | block_index.nStatus &= ~BLOCK_FAILED_MASK; |
3811 | 0 | m_blockman.m_dirty_blockindex.insert(&block_index); |
3812 | 0 | if (block_index.IsValid(BLOCK_VALID_TRANSACTIONS) && block_index.HaveNumChainTxs() && setBlockIndexCandidates.value_comp()(m_chain.Tip(), &block_index)) { Branch (3812:17): [True: 0, False: 0]
Branch (3812:17): [True: 0, False: 0]
Branch (3812:66): [True: 0, False: 0]
Branch (3812:99): [True: 0, False: 0]
|
3813 | 0 | setBlockIndexCandidates.insert(&block_index); |
3814 | 0 | } |
3815 | 0 | if (&block_index == m_chainman.m_best_invalid) { Branch (3815:17): [True: 0, False: 0]
|
3816 | | // Reset invalid block marker if it was pointing to one of those. |
3817 | 0 | m_chainman.m_best_invalid = nullptr; |
3818 | 0 | } |
3819 | 0 | m_chainman.m_failed_blocks.erase(&block_index); |
3820 | 0 | } |
3821 | 0 | } |
3822 | | |
3823 | | // Remove the invalidity flag from all ancestors too. |
3824 | 0 | while (pindex != nullptr) { Branch (3824:12): [True: 0, False: 0]
|
3825 | 0 | if (pindex->nStatus & BLOCK_FAILED_MASK) { Branch (3825:13): [True: 0, False: 0]
|
3826 | 0 | pindex->nStatus &= ~BLOCK_FAILED_MASK; |
3827 | 0 | m_blockman.m_dirty_blockindex.insert(pindex); |
3828 | 0 | m_chainman.m_failed_blocks.erase(pindex); |
3829 | 0 | } |
3830 | 0 | pindex = pindex->pprev; |
3831 | 0 | } |
3832 | 0 | } |
3833 | | |
3834 | | void Chainstate::TryAddBlockIndexCandidate(CBlockIndex* pindex) |
3835 | 0 | { |
3836 | 0 | AssertLockHeld(cs_main); |
3837 | | // The block only is a candidate for the most-work-chain if it has the same |
3838 | | // or more work than our current tip. |
3839 | 0 | if (m_chain.Tip() != nullptr && setBlockIndexCandidates.value_comp()(pindex, m_chain.Tip())) { Branch (3839:9): [True: 0, False: 0]
Branch (3839:9): [True: 0, False: 0]
Branch (3839:37): [True: 0, False: 0]
|
3840 | 0 | return; |
3841 | 0 | } |
3842 | | |
3843 | 0 | bool is_active_chainstate = this == &m_chainman.ActiveChainstate(); |
3844 | 0 | if (is_active_chainstate) { Branch (3844:9): [True: 0, False: 0]
|
3845 | | // The active chainstate should always add entries that have more |
3846 | | // work than the tip. |
3847 | 0 | setBlockIndexCandidates.insert(pindex); |
3848 | 0 | } else if (!m_disabled) { Branch (3848:16): [True: 0, False: 0]
|
3849 | | // For the background chainstate, we only consider connecting blocks |
3850 | | // towards the snapshot base (which can't be nullptr or else we'll |
3851 | | // never make progress). |
3852 | 0 | const CBlockIndex* snapshot_base{Assert(m_chainman.GetSnapshotBaseBlock())}; |
3853 | 0 | if (snapshot_base->GetAncestor(pindex->nHeight) == pindex) { Branch (3853:13): [True: 0, False: 0]
|
3854 | 0 | setBlockIndexCandidates.insert(pindex); |
3855 | 0 | } |
3856 | 0 | } |
3857 | 0 | } |
3858 | | |
3859 | | /** Mark a block as having its data received and checked (up to BLOCK_VALID_TRANSACTIONS). */ |
3860 | | void ChainstateManager::ReceivedBlockTransactions(const CBlock& block, CBlockIndex* pindexNew, const FlatFilePos& pos) |
3861 | 0 | { |
3862 | 0 | AssertLockHeld(cs_main); |
3863 | 0 | pindexNew->nTx = block.vtx.size(); |
3864 | | // Typically m_chain_tx_count will be 0 at this point, but it can be nonzero if this |
3865 | | // is a pruned block which is being downloaded again, or if this is an |
3866 | | // assumeutxo snapshot block which has a hardcoded m_chain_tx_count value from the |
3867 | | // snapshot metadata. If the pindex is not the snapshot block and the |
3868 | | // m_chain_tx_count value is not zero, assert that value is actually correct. |
3869 | 0 | auto prev_tx_sum = [](CBlockIndex& block) { return block.nTx + (block.pprev ? block.pprev->m_chain_tx_count : 0); }; Branch (3869:69): [True: 0, False: 0]
|
3870 | 0 | if (!Assume(pindexNew->m_chain_tx_count == 0 || pindexNew->m_chain_tx_count == prev_tx_sum(*pindexNew) || Branch (3870:9): [True: 0, False: 0]
|
3871 | 0 | pindexNew == GetSnapshotBaseBlock())) { |
3872 | 0 | LogWarning("Internal bug detected: block %d has unexpected m_chain_tx_count %i that should be %i (%s %s). Please report this issue here: %s\n", |
3873 | 0 | pindexNew->nHeight, pindexNew->m_chain_tx_count, prev_tx_sum(*pindexNew), PACKAGE_NAME, FormatFullVersion(), PACKAGE_BUGREPORT); |
3874 | 0 | pindexNew->m_chain_tx_count = 0; |
3875 | 0 | } |
3876 | 0 | pindexNew->nFile = pos.nFile; |
3877 | 0 | pindexNew->nDataPos = pos.nPos; |
3878 | 0 | pindexNew->nUndoPos = 0; |
3879 | 0 | pindexNew->nStatus |= BLOCK_HAVE_DATA; |
3880 | 0 | if (DeploymentActiveAt(*pindexNew, *this, Consensus::DEPLOYMENT_SEGWIT)) { Branch (3880:9): [True: 0, False: 0]
|
3881 | 0 | pindexNew->nStatus |= BLOCK_OPT_WITNESS; |
3882 | 0 | } |
3883 | 0 | pindexNew->RaiseValidity(BLOCK_VALID_TRANSACTIONS); |
3884 | 0 | m_blockman.m_dirty_blockindex.insert(pindexNew); |
3885 | |
|
3886 | 0 | if (pindexNew->pprev == nullptr || pindexNew->pprev->HaveNumChainTxs()) { Branch (3886:9): [True: 0, False: 0]
Branch (3886:40): [True: 0, False: 0]
|
3887 | | // If pindexNew is the genesis block or all parents are BLOCK_VALID_TRANSACTIONS. |
3888 | 0 | std::deque<CBlockIndex*> queue; |
3889 | 0 | queue.push_back(pindexNew); |
3890 | | |
3891 | | // Recursively process any descendant blocks that now may be eligible to be connected. |
3892 | 0 | while (!queue.empty()) { Branch (3892:16): [True: 0, False: 0]
|
3893 | 0 | CBlockIndex *pindex = queue.front(); |
3894 | 0 | queue.pop_front(); |
3895 | | // Before setting m_chain_tx_count, assert that it is 0 or already set to |
3896 | | // the correct value. This assert will fail after receiving the |
3897 | | // assumeutxo snapshot block if assumeutxo snapshot metadata has an |
3898 | | // incorrect hardcoded AssumeutxoData::m_chain_tx_count value. |
3899 | 0 | if (!Assume(pindex->m_chain_tx_count == 0 || pindex->m_chain_tx_count == prev_tx_sum(*pindex))) { Branch (3899:17): [True: 0, False: 0]
|
3900 | 0 | LogWarning("Internal bug detected: block %d has unexpected m_chain_tx_count %i that should be %i (%s %s). Please report this issue here: %s\n", |
3901 | 0 | pindex->nHeight, pindex->m_chain_tx_count, prev_tx_sum(*pindex), PACKAGE_NAME, FormatFullVersion(), PACKAGE_BUGREPORT); |
3902 | 0 | } |
3903 | 0 | pindex->m_chain_tx_count = prev_tx_sum(*pindex); |
3904 | 0 | pindex->nSequenceId = nBlockSequenceId++; |
3905 | 0 | for (Chainstate *c : GetAll()) { Branch (3905:32): [True: 0, False: 0]
|
3906 | 0 | c->TryAddBlockIndexCandidate(pindex); |
3907 | 0 | } |
3908 | 0 | std::pair<std::multimap<CBlockIndex*, CBlockIndex*>::iterator, std::multimap<CBlockIndex*, CBlockIndex*>::iterator> range = m_blockman.m_blocks_unlinked.equal_range(pindex); |
3909 | 0 | while (range.first != range.second) { Branch (3909:20): [True: 0, False: 0]
|
3910 | 0 | std::multimap<CBlockIndex*, CBlockIndex*>::iterator it = range.first; |
3911 | 0 | queue.push_back(it->second); |
3912 | 0 | range.first++; |
3913 | 0 | m_blockman.m_blocks_unlinked.erase(it); |
3914 | 0 | } |
3915 | 0 | } |
3916 | 0 | } else { |
3917 | 0 | if (pindexNew->pprev && pindexNew->pprev->IsValid(BLOCK_VALID_TREE)) { Branch (3917:13): [True: 0, False: 0]
Branch (3917:33): [True: 0, False: 0]
|
3918 | 0 | m_blockman.m_blocks_unlinked.insert(std::make_pair(pindexNew->pprev, pindexNew)); |
3919 | 0 | } |
3920 | 0 | } |
3921 | 0 | } |
3922 | | |
3923 | | static bool CheckBlockHeader(const CBlockHeader& block, BlockValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW = true) |
3924 | 13.6k | { |
3925 | | // Check proof of work matches claimed amount |
3926 | 13.6k | if (fCheckPOW && !CheckProofOfWork(block.GetHash(), block.nBits, consensusParams)) Branch (3926:9): [True: 13.6k, False: 0]
Branch (3926:22): [True: 0, False: 13.6k]
|
3927 | 0 | return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "high-hash", "proof of work failed"); |
3928 | | |
3929 | 13.6k | return true; |
3930 | 13.6k | } |
3931 | | |
3932 | | static bool CheckMerkleRoot(const CBlock& block, BlockValidationState& state) |
3933 | 13.6k | { |
3934 | 13.6k | if (block.m_checked_merkle_root) return true; Branch (3934:9): [True: 6.84k, False: 6.84k]
|
3935 | | |
3936 | 6.84k | bool mutated; |
3937 | 6.84k | uint256 merkle_root = BlockMerkleRoot(block, &mutated); |
3938 | 6.84k | if (block.hashMerkleRoot != merkle_root) { Branch (3938:9): [True: 0, False: 6.84k]
|
3939 | 0 | return state.Invalid( |
3940 | 0 | /*result=*/BlockValidationResult::BLOCK_MUTATED, |
3941 | 0 | /*reject_reason=*/"bad-txnmrklroot", |
3942 | 0 | /*debug_message=*/"hashMerkleRoot mismatch"); |
3943 | 0 | } |
3944 | | |
3945 | | // Check for merkle tree malleability (CVE-2012-2459): repeating sequences |
3946 | | // of transactions in a block without affecting the merkle root of a block, |
3947 | | // while still invalidating it. |
3948 | 6.84k | if (mutated) { Branch (3948:9): [True: 0, False: 6.84k]
|
3949 | 0 | return state.Invalid( |
3950 | 0 | /*result=*/BlockValidationResult::BLOCK_MUTATED, |
3951 | 0 | /*reject_reason=*/"bad-txns-duplicate", |
3952 | 0 | /*debug_message=*/"duplicate transaction"); |
3953 | 0 | } |
3954 | | |
3955 | 6.84k | block.m_checked_merkle_root = true; |
3956 | 6.84k | return true; |
3957 | 6.84k | } |
3958 | | |
3959 | | /** CheckWitnessMalleation performs checks for block malleation with regard to |
3960 | | * its witnesses. |
3961 | | * |
3962 | | * Note: If the witness commitment is expected (i.e. `expect_witness_commitment |
3963 | | * = true`), then the block is required to have at least one transaction and the |
3964 | | * first transaction needs to have at least one input. */ |
3965 | | static bool CheckWitnessMalleation(const CBlock& block, bool expect_witness_commitment, BlockValidationState& state) |
3966 | 6.84k | { |
3967 | 6.84k | if (expect_witness_commitment) { Branch (3967:9): [True: 0, False: 6.84k]
|
3968 | 0 | if (block.m_checked_witness_commitment) return true; Branch (3968:13): [True: 0, False: 0]
|
3969 | | |
3970 | 0 | int commitpos = GetWitnessCommitmentIndex(block); |
3971 | 0 | if (commitpos != NO_WITNESS_COMMITMENT) { Branch (3971:13): [True: 0, False: 0]
|
3972 | 0 | assert(!block.vtx.empty() && !block.vtx[0]->vin.empty()); |
3973 | 0 | const auto& witness_stack{block.vtx[0]->vin[0].scriptWitness.stack}; |
3974 | |
|
3975 | 0 | if (witness_stack.size() != 1 || witness_stack[0].size() != 32) { Branch (3975:17): [True: 0, False: 0]
Branch (3975:46): [True: 0, False: 0]
|
3976 | 0 | return state.Invalid( |
3977 | 0 | /*result=*/BlockValidationResult::BLOCK_MUTATED, |
3978 | 0 | /*reject_reason=*/"bad-witness-nonce-size", |
3979 | 0 | /*debug_message=*/strprintf("%s : invalid witness reserved value size", __func__)); |
3980 | 0 | } |
3981 | | |
3982 | | // The malleation check is ignored; as the transaction tree itself |
3983 | | // already does not permit it, it is impossible to trigger in the |
3984 | | // witness tree. |
3985 | 0 | uint256 hash_witness = BlockWitnessMerkleRoot(block, /*mutated=*/nullptr); |
3986 | |
|
3987 | 0 | CHash256().Write(hash_witness).Write(witness_stack[0]).Finalize(hash_witness); |
3988 | 0 | if (memcmp(hash_witness.begin(), &block.vtx[0]->vout[commitpos].scriptPubKey[6], 32)) { Branch (3988:17): [True: 0, False: 0]
|
3989 | 0 | return state.Invalid( |
3990 | 0 | /*result=*/BlockValidationResult::BLOCK_MUTATED, |
3991 | 0 | /*reject_reason=*/"bad-witness-merkle-match", |
3992 | 0 | /*debug_message=*/strprintf("%s : witness merkle commitment mismatch", __func__)); |
3993 | 0 | } |
3994 | | |
3995 | 0 | block.m_checked_witness_commitment = true; |
3996 | 0 | return true; |
3997 | 0 | } |
3998 | 0 | } |
3999 | | |
4000 | | // No witness data is allowed in blocks that don't commit to witness data, as this would otherwise leave room for spam |
4001 | 6.84k | for (const auto& tx : block.vtx) { Branch (4001:25): [True: 6.84k, False: 6.84k]
|
4002 | 6.84k | if (tx->HasWitness()) { Branch (4002:13): [True: 0, False: 6.84k]
|
4003 | 0 | return state.Invalid( |
4004 | 0 | /*result=*/BlockValidationResult::BLOCK_MUTATED, |
4005 | 0 | /*reject_reason=*/"unexpected-witness", |
4006 | 0 | /*debug_message=*/strprintf("%s : unexpected witness data found", __func__)); |
4007 | 0 | } |
4008 | 6.84k | } |
4009 | | |
4010 | 6.84k | return true; |
4011 | 6.84k | } |
4012 | | |
4013 | | bool CheckBlock(const CBlock& block, BlockValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW, bool fCheckMerkleRoot) |
4014 | 6.84k | { |
4015 | | // These are checks that are independent of context. |
4016 | | |
4017 | 6.84k | if (block.fChecked) Branch (4017:9): [True: 0, False: 6.84k]
|
4018 | 0 | return true; |
4019 | | |
4020 | | // Check that the header is valid (particularly PoW). This is mostly |
4021 | | // redundant with the call in AcceptBlockHeader. |
4022 | 6.84k | if (!CheckBlockHeader(block, state, consensusParams, fCheckPOW)) Branch (4022:9): [True: 0, False: 6.84k]
|
4023 | 0 | return false; |
4024 | | |
4025 | | // Signet only: check block solution |
4026 | 6.84k | if (consensusParams.signet_blocks && fCheckPOW && !CheckSignetBlockSolution(block, consensusParams)) { Branch (4026:9): [True: 0, False: 6.84k]
Branch (4026:42): [True: 0, False: 0]
Branch (4026:55): [True: 0, False: 0]
|
4027 | 0 | return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-signet-blksig", "signet block signature validation failure"); |
4028 | 0 | } |
4029 | | |
4030 | | // Check the merkle root. |
4031 | 6.84k | if (fCheckMerkleRoot && !CheckMerkleRoot(block, state)) { Branch (4031:9): [True: 6.84k, False: 0]
Branch (4031:29): [True: 0, False: 6.84k]
|
4032 | 0 | return false; |
4033 | 0 | } |
4034 | | |
4035 | | // All potential-corruption validation must be done before we do any |
4036 | | // transaction validation, as otherwise we may mark the header as invalid |
4037 | | // because we receive the wrong transactions for it. |
4038 | | // Note that witness malleability is checked in ContextualCheckBlock, so no |
4039 | | // checks that use witness data may be performed here. |
4040 | | |
4041 | | // Size limits |
4042 | 6.84k | if (block.vtx.empty() || block.vtx.size() * WITNESS_SCALE_FACTOR > MAX_BLOCK_WEIGHT || ::GetSerializeSize(TX_NO_WITNESS(block)) * WITNESS_SCALE_FACTOR > MAX_BLOCK_WEIGHT) Branch (4042:9): [True: 0, False: 6.84k]
Branch (4042:9): [True: 0, False: 6.84k]
Branch (4042:30): [True: 0, False: 6.84k]
Branch (4042:92): [True: 0, False: 6.84k]
|
4043 | 0 | return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-blk-length", "size limits failed"); |
4044 | | |
4045 | | // First transaction must be coinbase, the rest must not be |
4046 | 6.84k | if (block.vtx.empty() || !block.vtx[0]->IsCoinBase()) Branch (4046:9): [True: 0, False: 6.84k]
Branch (4046:30): [True: 0, False: 6.84k]
|
4047 | 0 | return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-cb-missing", "first tx is not coinbase"); |
4048 | 6.84k | for (unsigned int i = 1; i < block.vtx.size(); i++) Branch (4048:30): [True: 0, False: 6.84k]
|
4049 | 0 | if (block.vtx[i]->IsCoinBase()) Branch (4049:13): [True: 0, False: 0]
|
4050 | 0 | return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-cb-multiple", "more than one coinbase"); |
4051 | | |
4052 | | // Check transactions |
4053 | | // Must check for duplicate inputs (see CVE-2018-17144) |
4054 | 6.84k | for (const auto& tx : block.vtx) { Branch (4054:25): [True: 6.84k, False: 6.84k]
|
4055 | 6.84k | TxValidationState tx_state; |
4056 | 6.84k | if (!CheckTransaction(*tx, tx_state)) { Branch (4056:13): [True: 0, False: 6.84k]
|
4057 | | // CheckBlock() does context-free validation checks. The only |
4058 | | // possible failures are consensus failures. |
4059 | 0 | assert(tx_state.GetResult() == TxValidationResult::TX_CONSENSUS); |
4060 | 0 | return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(), |
4061 | 0 | strprintf("Transaction check failed (tx hash %s) %s", tx->GetHash().ToString(), tx_state.GetDebugMessage())); |
4062 | 0 | } |
4063 | 6.84k | } |
4064 | 6.84k | unsigned int nSigOps = 0; |
4065 | 6.84k | for (const auto& tx : block.vtx) Branch (4065:25): [True: 6.84k, False: 6.84k]
|
4066 | 6.84k | { |
4067 | 6.84k | nSigOps += GetLegacySigOpCount(*tx); |
4068 | 6.84k | } |
4069 | 6.84k | if (nSigOps * WITNESS_SCALE_FACTOR > MAX_BLOCK_SIGOPS_COST) Branch (4069:9): [True: 0, False: 6.84k]
|
4070 | 0 | return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-blk-sigops", "out-of-bounds SigOpCount"); |
4071 | | |
4072 | 6.84k | if (fCheckPOW && fCheckMerkleRoot) Branch (4072:9): [True: 6.84k, False: 0]
Branch (4072:22): [True: 6.84k, False: 0]
|
4073 | 6.84k | block.fChecked = true; |
4074 | | |
4075 | 6.84k | return true; |
4076 | 6.84k | } |
4077 | | |
4078 | | void ChainstateManager::UpdateUncommittedBlockStructures(CBlock& block, const CBlockIndex* pindexPrev) const |
4079 | 0 | { |
4080 | 0 | int commitpos = GetWitnessCommitmentIndex(block); |
4081 | 0 | static const std::vector<unsigned char> nonce(32, 0x00); |
4082 | 0 | if (commitpos != NO_WITNESS_COMMITMENT && DeploymentActiveAfter(pindexPrev, *this, Consensus::DEPLOYMENT_SEGWIT) && !block.vtx[0]->HasWitness()) { Branch (4082:9): [True: 0, False: 0]
Branch (4082:47): [True: 0, False: 0]
Branch (4082:121): [True: 0, False: 0]
|
4083 | 0 | CMutableTransaction tx(*block.vtx[0]); |
4084 | 0 | tx.vin[0].scriptWitness.stack.resize(1); |
4085 | 0 | tx.vin[0].scriptWitness.stack[0] = nonce; |
4086 | 0 | block.vtx[0] = MakeTransactionRef(std::move(tx)); |
4087 | 0 | } |
4088 | 0 | } |
4089 | | |
4090 | | std::vector<unsigned char> ChainstateManager::GenerateCoinbaseCommitment(CBlock& block, const CBlockIndex* pindexPrev) const |
4091 | 0 | { |
4092 | 0 | std::vector<unsigned char> commitment; |
4093 | 0 | int commitpos = GetWitnessCommitmentIndex(block); |
4094 | 0 | std::vector<unsigned char> ret(32, 0x00); |
4095 | 0 | if (commitpos == NO_WITNESS_COMMITMENT) { Branch (4095:9): [True: 0, False: 0]
|
4096 | 0 | uint256 witnessroot = BlockWitnessMerkleRoot(block, nullptr); |
4097 | 0 | CHash256().Write(witnessroot).Write(ret).Finalize(witnessroot); |
4098 | 0 | CTxOut out; |
4099 | 0 | out.nValue = 0; |
4100 | 0 | out.scriptPubKey.resize(MINIMUM_WITNESS_COMMITMENT); |
4101 | 0 | out.scriptPubKey[0] = OP_RETURN; |
4102 | 0 | out.scriptPubKey[1] = 0x24; |
4103 | 0 | out.scriptPubKey[2] = 0xaa; |
4104 | 0 | out.scriptPubKey[3] = 0x21; |
4105 | 0 | out.scriptPubKey[4] = 0xa9; |
4106 | 0 | out.scriptPubKey[5] = 0xed; |
4107 | 0 | memcpy(&out.scriptPubKey[6], witnessroot.begin(), 32); |
4108 | 0 | commitment = std::vector<unsigned char>(out.scriptPubKey.begin(), out.scriptPubKey.end()); |
4109 | 0 | CMutableTransaction tx(*block.vtx[0]); |
4110 | 0 | tx.vout.push_back(out); |
4111 | 0 | block.vtx[0] = MakeTransactionRef(std::move(tx)); |
4112 | 0 | } |
4113 | 0 | UpdateUncommittedBlockStructures(block, pindexPrev); |
4114 | 0 | return commitment; |
4115 | 0 | } |
4116 | | |
4117 | | bool HasValidProofOfWork(const std::vector<CBlockHeader>& headers, const Consensus::Params& consensusParams) |
4118 | 3.25k | { |
4119 | 3.25k | return std::all_of(headers.cbegin(), headers.cend(), |
4120 | 52.1k | [&](const auto& header) { return CheckProofOfWork(header.GetHash(), header.nBits, consensusParams);}); |
4121 | 3.25k | } |
4122 | | |
4123 | | bool IsBlockMutated(const CBlock& block, bool check_witness_root) |
4124 | 6.84k | { |
4125 | 6.84k | BlockValidationState state; |
4126 | 6.84k | if (!CheckMerkleRoot(block, state)) { Branch (4126:9): [True: 0, False: 6.84k]
|
4127 | 0 | LogDebug(BCLog::VALIDATION, "Block mutated: %s\n", state.ToString()); |
4128 | 0 | return true; |
4129 | 0 | } |
4130 | | |
4131 | 6.84k | if (block.vtx.empty() || !block.vtx[0]->IsCoinBase()) { Branch (4131:9): [True: 0, False: 6.84k]
Branch (4131:30): [True: 0, False: 6.84k]
|
4132 | | // Consider the block mutated if any transaction is 64 bytes in size (see 3.1 |
4133 | | // in "Weaknesses in Bitcoin’s Merkle Root Construction": |
4134 | | // https://lists.linuxfoundation.org/pipermail/bitcoin-dev/attachments/20190225/a27d8837/attachment-0001.pdf). |
4135 | | // |
4136 | | // Note: This is not a consensus change as this only applies to blocks that |
4137 | | // don't have a coinbase transaction and would therefore already be invalid. |
4138 | 0 | return std::any_of(block.vtx.begin(), block.vtx.end(), |
4139 | 0 | [](auto& tx) { return GetSerializeSize(TX_NO_WITNESS(tx)) == 64; }); |
4140 | 6.84k | } else { |
4141 | | // Theoretically it is still possible for a block with a 64 byte |
4142 | | // coinbase transaction to be mutated but we neglect that possibility |
4143 | | // here as it requires at least 224 bits of work. |
4144 | 6.84k | } |
4145 | | |
4146 | 6.84k | if (!CheckWitnessMalleation(block, check_witness_root, state)) { Branch (4146:9): [True: 0, False: 6.84k]
|
4147 | 0 | LogDebug(BCLog::VALIDATION, "Block mutated: %s\n", state.ToString()); |
4148 | 0 | return true; |
4149 | 0 | } |
4150 | | |
4151 | 6.84k | return false; |
4152 | 6.84k | } |
4153 | | |
4154 | | arith_uint256 CalculateClaimedHeadersWork(const std::vector<CBlockHeader>& headers) |
4155 | 8.73k | { |
4156 | 8.73k | arith_uint256 total_work{0}; |
4157 | 11.7k | for (const CBlockHeader& header : headers) { Branch (4157:37): [True: 11.7k, False: 8.73k]
|
4158 | 11.7k | CBlockIndex dummy(header); |
4159 | 11.7k | total_work += GetBlockProof(dummy); |
4160 | 11.7k | } |
4161 | 8.73k | return total_work; |
4162 | 8.73k | } |
4163 | | |
4164 | | /** Context-dependent validity checks. |
4165 | | * By "context", we mean only the previous block headers, but not the UTXO |
4166 | | * set; UTXO-related validity checks are done in ConnectBlock(). |
4167 | | * NOTE: This function is not currently invoked by ConnectBlock(), so we |
4168 | | * should consider upgrade issues if we change which consensus rules are |
4169 | | * enforced in this function (eg by adding a new consensus rule). See comment |
4170 | | * in ConnectBlock(). |
4171 | | * Note that -reindex-chainstate skips the validation that happens here! |
4172 | | */ |
4173 | | static bool ContextualCheckBlockHeader(const CBlockHeader& block, BlockValidationState& state, BlockManager& blockman, const ChainstateManager& chainman, const CBlockIndex* pindexPrev) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) |
4174 | 6.84k | { |
4175 | 6.84k | AssertLockHeld(::cs_main); |
4176 | 6.84k | assert(pindexPrev != nullptr); |
4177 | 6.84k | const int nHeight = pindexPrev->nHeight + 1; |
4178 | | |
4179 | | // Check proof of work |
4180 | 6.84k | const Consensus::Params& consensusParams = chainman.GetConsensus(); |
4181 | 6.84k | if (block.nBits != GetNextWorkRequired(pindexPrev, &block, consensusParams)) Branch (4181:9): [True: 279, False: 6.56k]
|
4182 | 279 | return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "bad-diffbits", "incorrect proof of work"); |
4183 | | |
4184 | | // Check against checkpoints |
4185 | 6.56k | if (chainman.m_options.checkpoints_enabled) { Branch (4185:9): [True: 6.56k, False: 0]
|
4186 | | // Don't accept any forks from the main chain prior to last checkpoint. |
4187 | | // GetLastCheckpoint finds the last checkpoint in MapCheckpoints that's in our |
4188 | | // BlockIndex(). |
4189 | 6.56k | const CBlockIndex* pcheckpoint = blockman.GetLastCheckpoint(chainman.GetParams().Checkpoints()); |
4190 | 6.56k | if (pcheckpoint && nHeight < pcheckpoint->nHeight) { Branch (4190:13): [True: 0, False: 6.56k]
Branch (4190:28): [True: 0, False: 0]
|
4191 | 0 | LogPrintf("ERROR: %s: forked chain older than last checkpoint (height %d)\n", __func__, nHeight); |
4192 | 0 | return state.Invalid(BlockValidationResult::BLOCK_CHECKPOINT, "bad-fork-prior-to-checkpoint"); |
4193 | 0 | } |
4194 | 6.56k | } |
4195 | | |
4196 | | // Check timestamp against prev |
4197 | 6.56k | if (block.GetBlockTime() <= pindexPrev->GetMedianTimePast()) Branch (4197:9): [True: 1.08k, False: 5.47k]
|
4198 | 1.08k | return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "time-too-old", "block's timestamp is too early"); |
4199 | | |
4200 | | // Testnet4 only: Check timestamp against prev for difficulty-adjustment |
4201 | | // blocks to prevent timewarp attacks (see https://github.com/bitcoin/bitcoin/pull/15482). |
4202 | 5.47k | if (consensusParams.enforce_BIP94) { Branch (4202:9): [True: 0, False: 5.47k]
|
4203 | | // Check timestamp for the first block of each difficulty adjustment |
4204 | | // interval, except the genesis block. |
4205 | 0 | if (nHeight % consensusParams.DifficultyAdjustmentInterval() == 0) { Branch (4205:13): [True: 0, False: 0]
|
4206 | 0 | if (block.GetBlockTime() < pindexPrev->GetBlockTime() - MAX_TIMEWARP) { Branch (4206:17): [True: 0, False: 0]
|
4207 | 0 | return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "time-timewarp-attack", "block's timestamp is too early on diff adjustment block"); |
4208 | 0 | } |
4209 | 0 | } |
4210 | 0 | } |
4211 | | |
4212 | | // Check timestamp |
4213 | 5.47k | if (block.Time() > NodeClock::now() + std::chrono::seconds{MAX_FUTURE_BLOCK_TIME}) { Branch (4213:9): [True: 5.40k, False: 74]
|
4214 | 5.40k | return state.Invalid(BlockValidationResult::BLOCK_TIME_FUTURE, "time-too-new", "block timestamp too far in the future"); |
4215 | 5.40k | } |
4216 | | |
4217 | | // Reject blocks with outdated version |
4218 | 74 | if ((block.nVersion < 2 && DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_HEIGHTINCB)) || Branch (4218:10): [True: 74, False: 0]
Branch (4218:32): [True: 0, False: 74]
|
4219 | 74 | (block.nVersion < 3 && DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_DERSIG)) || Branch (4219:10): [True: 74, False: 0]
Branch (4219:32): [True: 0, False: 74]
|
4220 | 74 | (block.nVersion < 4 && DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_CLTV))) { Branch (4220:10): [True: 74, False: 0]
Branch (4220:32): [True: 0, False: 74]
|
4221 | 0 | return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, strprintf("bad-version(0x%08x)", block.nVersion), |
4222 | 0 | strprintf("rejected nVersion=0x%08x block", block.nVersion)); |
4223 | 0 | } |
4224 | | |
4225 | 74 | return true; |
4226 | 74 | } |
4227 | | |
4228 | | /** NOTE: This function is not currently invoked by ConnectBlock(), so we |
4229 | | * should consider upgrade issues if we change which consensus rules are |
4230 | | * enforced in this function (eg by adding a new consensus rule). See comment |
4231 | | * in ConnectBlock(). |
4232 | | * Note that -reindex-chainstate skips the validation that happens here! |
4233 | | */ |
4234 | | static bool ContextualCheckBlock(const CBlock& block, BlockValidationState& state, const ChainstateManager& chainman, const CBlockIndex* pindexPrev) |
4235 | 0 | { |
4236 | 0 | const int nHeight = pindexPrev == nullptr ? 0 : pindexPrev->nHeight + 1; Branch (4236:25): [True: 0, False: 0]
|
4237 | | |
4238 | | // Enforce BIP113 (Median Time Past). |
4239 | 0 | bool enforce_locktime_median_time_past{false}; |
4240 | 0 | if (DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_CSV)) { Branch (4240:9): [True: 0, False: 0]
|
4241 | 0 | assert(pindexPrev != nullptr); |
4242 | 0 | enforce_locktime_median_time_past = true; |
4243 | 0 | } |
4244 | | |
4245 | 0 | const int64_t nLockTimeCutoff{enforce_locktime_median_time_past ? Branch (4245:35): [True: 0, False: 0]
|
4246 | 0 | pindexPrev->GetMedianTimePast() : |
4247 | 0 | block.GetBlockTime()}; |
4248 | | |
4249 | | // Check that all transactions are finalized |
4250 | 0 | for (const auto& tx : block.vtx) { Branch (4250:25): [True: 0, False: 0]
|
4251 | 0 | if (!IsFinalTx(*tx, nHeight, nLockTimeCutoff)) { Branch (4251:13): [True: 0, False: 0]
|
4252 | 0 | return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-txns-nonfinal", "non-final transaction"); |
4253 | 0 | } |
4254 | 0 | } |
4255 | | |
4256 | | // Enforce rule that the coinbase starts with serialized block height |
4257 | 0 | if (DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_HEIGHTINCB)) Branch (4257:9): [True: 0, False: 0]
|
4258 | 0 | { |
4259 | 0 | CScript expect = CScript() << nHeight; |
4260 | 0 | if (block.vtx[0]->vin[0].scriptSig.size() < expect.size() || Branch (4260:13): [True: 0, False: 0]
|
4261 | 0 | !std::equal(expect.begin(), expect.end(), block.vtx[0]->vin[0].scriptSig.begin())) { Branch (4261:13): [True: 0, False: 0]
|
4262 | 0 | return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-cb-height", "block height mismatch in coinbase"); |
4263 | 0 | } |
4264 | 0 | } |
4265 | | |
4266 | | // Validation for witness commitments. |
4267 | | // * We compute the witness hash (which is the hash including witnesses) of all the block's transactions, except the |
4268 | | // coinbase (where 0x0000....0000 is used instead). |
4269 | | // * The coinbase scriptWitness is a stack of a single 32-byte vector, containing a witness reserved value (unconstrained). |
4270 | | // * We build a merkle tree with all those witness hashes as leaves (similar to the hashMerkleRoot in the block header). |
4271 | | // * There must be at least one output whose scriptPubKey is a single 36-byte push, the first 4 bytes of which are |
4272 | | // {0xaa, 0x21, 0xa9, 0xed}, and the following 32 bytes are SHA256^2(witness root, witness reserved value). In case there are |
4273 | | // multiple, the last one is used. |
4274 | 0 | if (!CheckWitnessMalleation(block, DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_SEGWIT), state)) { Branch (4274:9): [True: 0, False: 0]
|
4275 | 0 | return false; |
4276 | 0 | } |
4277 | | |
4278 | | // After the coinbase witness reserved value and commitment are verified, |
4279 | | // we can check if the block weight passes (before we've checked the |
4280 | | // coinbase witness, it would be possible for the weight to be too |
4281 | | // large by filling up the coinbase witness, which doesn't change |
4282 | | // the block hash, so we couldn't mark the block as permanently |
4283 | | // failed). |
4284 | 0 | if (GetBlockWeight(block) > MAX_BLOCK_WEIGHT) { Branch (4284:9): [True: 0, False: 0]
|
4285 | 0 | return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-blk-weight", strprintf("%s : weight limit failed", __func__)); |
4286 | 0 | } |
4287 | | |
4288 | 0 | return true; |
4289 | 0 | } |
4290 | | |
4291 | | bool ChainstateManager::AcceptBlockHeader(const CBlockHeader& block, BlockValidationState& state, CBlockIndex** ppindex, bool min_pow_checked) |
4292 | 6.84k | { |
4293 | 6.84k | AssertLockHeld(cs_main); |
4294 | | |
4295 | | // Check for duplicate |
4296 | 6.84k | uint256 hash = block.GetHash(); |
4297 | 6.84k | BlockMap::iterator miSelf{m_blockman.m_block_index.find(hash)}; |
4298 | 6.84k | if (hash != GetConsensus().hashGenesisBlock) { Branch (4298:9): [True: 6.84k, False: 0]
|
4299 | 6.84k | if (miSelf != m_blockman.m_block_index.end()) { Branch (4299:13): [True: 0, False: 6.84k]
|
4300 | | // Block header is already known. |
4301 | 0 | CBlockIndex* pindex = &(miSelf->second); |
4302 | 0 | if (ppindex) Branch (4302:17): [True: 0, False: 0]
|
4303 | 0 | *ppindex = pindex; |
4304 | 0 | if (pindex->nStatus & BLOCK_FAILED_MASK) { Branch (4304:17): [True: 0, False: 0]
|
4305 | 0 | LogPrint(BCLog::VALIDATION, "%s: block %s is marked invalid\n", __func__, hash.ToString()); |
4306 | 0 | return state.Invalid(BlockValidationResult::BLOCK_CACHED_INVALID, "duplicate"); |
4307 | 0 | } |
4308 | 0 | return true; |
4309 | 0 | } |
4310 | | |
4311 | 6.84k | if (!CheckBlockHeader(block, state, GetConsensus())) { Branch (4311:13): [True: 0, False: 6.84k]
|
4312 | 0 | LogPrint(BCLog::VALIDATION, "%s: Consensus::CheckBlockHeader: %s, %s\n", __func__, hash.ToString(), state.ToString()); |
4313 | 0 | return false; |
4314 | 0 | } |
4315 | | |
4316 | | // Get prev block index |
4317 | 6.84k | CBlockIndex* pindexPrev = nullptr; |
4318 | 6.84k | BlockMap::iterator mi{m_blockman.m_block_index.find(block.hashPrevBlock)}; |
4319 | 6.84k | if (mi == m_blockman.m_block_index.end()) { Branch (4319:13): [True: 0, False: 6.84k]
|
4320 | 0 | LogPrint(BCLog::VALIDATION, "header %s has prev block not found: %s\n", hash.ToString(), block.hashPrevBlock.ToString()); |
4321 | 0 | return state.Invalid(BlockValidationResult::BLOCK_MISSING_PREV, "prev-blk-not-found"); |
4322 | 0 | } |
4323 | 6.84k | pindexPrev = &((*mi).second); |
4324 | 6.84k | if (pindexPrev->nStatus & BLOCK_FAILED_MASK) { Branch (4324:13): [True: 0, False: 6.84k]
|
4325 | 0 | LogPrint(BCLog::VALIDATION, "header %s has prev block invalid: %s\n", hash.ToString(), block.hashPrevBlock.ToString()); |
4326 | 0 | return state.Invalid(BlockValidationResult::BLOCK_INVALID_PREV, "bad-prevblk"); |
4327 | 0 | } |
4328 | 6.84k | if (!ContextualCheckBlockHeader(block, state, m_blockman, *this, pindexPrev)) { Branch (4328:13): [True: 6.77k, False: 74]
|
4329 | 6.77k | LogPrint(BCLog::VALIDATION, "%s: Consensus::ContextualCheckBlockHeader: %s, %s\n", __func__, hash.ToString(), state.ToString()); |
4330 | 6.77k | return false; |
4331 | 6.77k | } |
4332 | | |
4333 | | /* Determine if this block descends from any block which has been found |
4334 | | * invalid (m_failed_blocks), then mark pindexPrev and any blocks between |
4335 | | * them as failed. For example: |
4336 | | * |
4337 | | * D3 |
4338 | | * / |
4339 | | * B2 - C2 |
4340 | | * / \ |
4341 | | * A D2 - E2 - F2 |
4342 | | * \ |
4343 | | * B1 - C1 - D1 - E1 |
4344 | | * |
4345 | | * In the case that we attempted to reorg from E1 to F2, only to find |
4346 | | * C2 to be invalid, we would mark D2, E2, and F2 as BLOCK_FAILED_CHILD |
4347 | | * but NOT D3 (it was not in any of our candidate sets at the time). |
4348 | | * |
4349 | | * In any case D3 will also be marked as BLOCK_FAILED_CHILD at restart |
4350 | | * in LoadBlockIndex. |
4351 | | */ |
4352 | 74 | if (!pindexPrev->IsValid(BLOCK_VALID_SCRIPTS)) { Branch (4352:13): [True: 74, False: 0]
|
4353 | | // The above does not mean "invalid": it checks if the previous block |
4354 | | // hasn't been validated up to BLOCK_VALID_SCRIPTS. This is a performance |
4355 | | // optimization, in the common case of adding a new block to the tip, |
4356 | | // we don't need to iterate over the failed blocks list. |
4357 | 74 | for (const CBlockIndex* failedit : m_failed_blocks) { Branch (4357:46): [True: 0, False: 74]
|
4358 | 0 | if (pindexPrev->GetAncestor(failedit->nHeight) == failedit) { Branch (4358:21): [True: 0, False: 0]
|
4359 | 0 | assert(failedit->nStatus & BLOCK_FAILED_VALID); |
4360 | 0 | CBlockIndex* invalid_walk = pindexPrev; |
4361 | 0 | while (invalid_walk != failedit) { Branch (4361:28): [True: 0, False: 0]
|
4362 | 0 | invalid_walk->nStatus |= BLOCK_FAILED_CHILD; |
4363 | 0 | m_blockman.m_dirty_blockindex.insert(invalid_walk); |
4364 | 0 | invalid_walk = invalid_walk->pprev; |
4365 | 0 | } |
4366 | 0 | LogPrint(BCLog::VALIDATION, "header %s has prev block invalid: %s\n", hash.ToString(), block.hashPrevBlock.ToString()); |
4367 | 0 | return state.Invalid(BlockValidationResult::BLOCK_INVALID_PREV, "bad-prevblk"); |
4368 | 0 | } |
4369 | 0 | } |
4370 | 74 | } |
4371 | 74 | } |
4372 | 74 | if (!min_pow_checked) { Branch (4372:9): [True: 74, False: 0]
|
4373 | 74 | LogPrint(BCLog::VALIDATION, "%s: not adding new block header %s, missing anti-dos proof-of-work validation\n", __func__, hash.ToString()); |
4374 | 74 | return state.Invalid(BlockValidationResult::BLOCK_HEADER_LOW_WORK, "too-little-chainwork"); |
4375 | 74 | } |
4376 | 0 | CBlockIndex* pindex{m_blockman.AddToBlockIndex(block, m_best_header)}; |
4377 | |
|
4378 | 0 | if (ppindex) Branch (4378:9): [True: 0, False: 0]
|
4379 | 0 | *ppindex = pindex; |
4380 | | |
4381 | | // Since this is the earliest point at which we have determined that a |
4382 | | // header is both new and valid, log here. |
4383 | | // |
4384 | | // These messages are valuable for detecting potential selfish mining behavior; |
4385 | | // if multiple displacing headers are seen near simultaneously across many |
4386 | | // nodes in the network, this might be an indication of selfish mining. Having |
4387 | | // this log by default when not in IBD ensures broad availability of this data |
4388 | | // in case investigation is merited. |
4389 | 0 | const auto msg = strprintf( |
4390 | 0 | "Saw new header hash=%s height=%d", hash.ToString(), pindex->nHeight); |
4391 | |
|
4392 | 0 | if (IsInitialBlockDownload()) { Branch (4392:9): [True: 0, False: 0]
|
4393 | 0 | LogPrintLevel(BCLog::VALIDATION, BCLog::Level::Debug, "%s\n", msg); |
4394 | 0 | } else { |
4395 | 0 | LogPrintf("%s\n", msg); |
4396 | 0 | } |
4397 | |
|
4398 | 0 | return true; |
4399 | 74 | } |
4400 | | |
4401 | | // Exposed wrapper for AcceptBlockHeader |
4402 | | bool ChainstateManager::ProcessNewBlockHeaders(const std::vector<CBlockHeader>& headers, bool min_pow_checked, BlockValidationState& state, const CBlockIndex** ppindex) |
4403 | 0 | { |
4404 | 0 | AssertLockNotHeld(cs_main); |
4405 | 0 | { |
4406 | 0 | LOCK(cs_main); |
4407 | 0 | for (const CBlockHeader& header : headers) { Branch (4407:41): [True: 0, False: 0]
|
4408 | 0 | CBlockIndex *pindex = nullptr; // Use a temp pindex instead of ppindex to avoid a const_cast |
4409 | 0 | bool accepted{AcceptBlockHeader(header, state, &pindex, min_pow_checked)}; |
4410 | 0 | CheckBlockIndex(); |
4411 | |
|
4412 | 0 | if (!accepted) { Branch (4412:17): [True: 0, False: 0]
|
4413 | 0 | return false; |
4414 | 0 | } |
4415 | 0 | if (ppindex) { Branch (4415:17): [True: 0, False: 0]
|
4416 | 0 | *ppindex = pindex; |
4417 | 0 | } |
4418 | 0 | } |
4419 | 0 | } |
4420 | 0 | if (NotifyHeaderTip()) { Branch (4420:9): [True: 0, False: 0]
|
4421 | 0 | if (IsInitialBlockDownload() && ppindex && *ppindex) { Branch (4421:13): [True: 0, False: 0]
Branch (4421:41): [True: 0, False: 0]
Branch (4421:52): [True: 0, False: 0]
|
4422 | 0 | const CBlockIndex& last_accepted{**ppindex}; |
4423 | 0 | int64_t blocks_left{(NodeClock::now() - last_accepted.Time()) / GetConsensus().PowTargetSpacing()}; |
4424 | 0 | blocks_left = std::max<int64_t>(0, blocks_left); |
4425 | 0 | const double progress{100.0 * last_accepted.nHeight / (last_accepted.nHeight + blocks_left)}; |
4426 | 0 | LogInfo("Synchronizing blockheaders, height: %d (~%.2f%%)\n", last_accepted.nHeight, progress); |
4427 | 0 | } |
4428 | 0 | } |
4429 | 0 | return true; |
4430 | 0 | } |
4431 | | |
4432 | | void ChainstateManager::ReportHeadersPresync(const arith_uint256& work, int64_t height, int64_t timestamp) |
4433 | 1.58k | { |
4434 | 1.58k | AssertLockNotHeld(cs_main); |
4435 | 1.58k | { |
4436 | 1.58k | LOCK(cs_main); |
4437 | | // Don't report headers presync progress if we already have a post-minchainwork header chain. |
4438 | | // This means we lose reporting for potentially legitimate, but unlikely, deep reorgs, but |
4439 | | // prevent attackers that spam low-work headers from filling our logs. |
4440 | 1.58k | if (m_best_header->nChainWork >= UintToArith256(GetConsensus().nMinimumChainWork)) return; Branch (4440:13): [True: 0, False: 1.58k]
|
4441 | | // Rate limit headers presync updates to 4 per second, as these are not subject to DoS |
4442 | | // protection. |
4443 | 1.58k | auto now = std::chrono::steady_clock::now(); |
4444 | 1.58k | if (now < m_last_presync_update + std::chrono::milliseconds{250}) return; Branch (4444:13): [True: 1.57k, False: 14]
|
4445 | 14 | m_last_presync_update = now; |
4446 | 14 | } |
4447 | 0 | bool initial_download = IsInitialBlockDownload(); |
4448 | 14 | GetNotifications().headerTip(GetSynchronizationState(initial_download, m_blockman.m_blockfiles_indexed), height, timestamp, /*presync=*/true); |
4449 | 14 | if (initial_download) { Branch (4449:9): [True: 14, False: 0]
|
4450 | 14 | int64_t blocks_left{(NodeClock::now() - NodeSeconds{std::chrono::seconds{timestamp}}) / GetConsensus().PowTargetSpacing()}; |
4451 | 14 | blocks_left = std::max<int64_t>(0, blocks_left); |
4452 | 14 | const double progress{100.0 * height / (height + blocks_left)}; |
4453 | 14 | LogInfo("Pre-synchronizing blockheaders, height: %d (~%.2f%%)\n", height, progress); |
4454 | 14 | } |
4455 | 14 | } |
4456 | | |
4457 | | /** Store block on disk. If dbp is non-nullptr, the file is known to already reside on disk */ |
4458 | | 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) |
4459 | 6.84k | { |
4460 | 6.84k | const CBlock& block = *pblock; |
4461 | | |
4462 | 6.84k | if (fNewBlock) *fNewBlock = false; Branch (4462:9): [True: 6.84k, False: 0]
|
4463 | 6.84k | AssertLockHeld(cs_main); |
4464 | | |
4465 | 6.84k | CBlockIndex *pindexDummy = nullptr; |
4466 | 6.84k | CBlockIndex *&pindex = ppindex ? *ppindex : pindexDummy; Branch (4466:28): [True: 6.84k, False: 0]
|
4467 | | |
4468 | 6.84k | bool accepted_header{AcceptBlockHeader(block, state, &pindex, min_pow_checked)}; |
4469 | 6.84k | CheckBlockIndex(); |
4470 | | |
4471 | 6.84k | if (!accepted_header) Branch (4471:9): [True: 6.84k, False: 0]
|
4472 | 6.84k | return false; |
4473 | | |
4474 | | // Check all requested blocks that we do not already have for validity and |
4475 | | // save them to disk. Skip processing of unrequested blocks as an anti-DoS |
4476 | | // measure, unless the blocks have more work than the active chain tip, and |
4477 | | // aren't too far ahead of it, so are likely to be attached soon. |
4478 | 0 | bool fAlreadyHave = pindex->nStatus & BLOCK_HAVE_DATA; |
4479 | 0 | bool fHasMoreOrSameWork = (ActiveTip() ? pindex->nChainWork >= ActiveTip()->nChainWork : true); Branch (4479:32): [True: 0, False: 0]
|
4480 | | // Blocks that are too out-of-order needlessly limit the effectiveness of |
4481 | | // pruning, because pruning will not delete block files that contain any |
4482 | | // blocks which are too close in height to the tip. Apply this test |
4483 | | // regardless of whether pruning is enabled; it should generally be safe to |
4484 | | // not process unrequested blocks. |
4485 | 0 | bool fTooFarAhead{pindex->nHeight > ActiveHeight() + int(MIN_BLOCKS_TO_KEEP)}; |
4486 | | |
4487 | | // TODO: Decouple this function from the block download logic by removing fRequested |
4488 | | // This requires some new chain data structure to efficiently look up if a |
4489 | | // block is in a chain leading to a candidate for best tip, despite not |
4490 | | // being such a candidate itself. |
4491 | | // Note that this would break the getblockfrompeer RPC |
4492 | | |
4493 | | // TODO: deal better with return value and error conditions for duplicate |
4494 | | // and unrequested blocks. |
4495 | 0 | if (fAlreadyHave) return true; Branch (4495:9): [True: 0, False: 0]
|
4496 | 0 | if (!fRequested) { // If we didn't ask for it: Branch (4496:9): [True: 0, False: 0]
|
4497 | 0 | if (pindex->nTx != 0) return true; // This is a previously-processed block that was pruned Branch (4497:13): [True: 0, False: 0]
|
4498 | 0 | if (!fHasMoreOrSameWork) return true; // Don't process less-work chains Branch (4498:13): [True: 0, False: 0]
|
4499 | 0 | if (fTooFarAhead) return true; // Block height is too high Branch (4499:13): [True: 0, False: 0]
|
4500 | | |
4501 | | // Protect against DoS attacks from low-work chains. |
4502 | | // If our tip is behind, a peer could try to send us |
4503 | | // low-work blocks on a fake chain that we would never |
4504 | | // request; don't process these. |
4505 | 0 | if (pindex->nChainWork < MinimumChainWork()) return true; Branch (4505:13): [True: 0, False: 0]
|
4506 | 0 | } |
4507 | | |
4508 | 0 | const CChainParams& params{GetParams()}; |
4509 | |
|
4510 | 0 | if (!CheckBlock(block, state, params.GetConsensus()) || Branch (4510:9): [True: 0, False: 0]
|
4511 | 0 | !ContextualCheckBlock(block, state, *this, pindex->pprev)) { Branch (4511:9): [True: 0, False: 0]
|
4512 | 0 | if (state.IsInvalid() && state.GetResult() != BlockValidationResult::BLOCK_MUTATED) { Branch (4512:13): [True: 0, False: 0]
Branch (4512:34): [True: 0, False: 0]
|
4513 | 0 | pindex->nStatus |= BLOCK_FAILED_VALID; |
4514 | 0 | m_blockman.m_dirty_blockindex.insert(pindex); |
4515 | 0 | } |
4516 | 0 | LogError("%s: %s\n", __func__, state.ToString()); |
4517 | 0 | return false; |
4518 | 0 | } |
4519 | | |
4520 | | // Header is valid/has work, merkle tree and segwit merkle tree are good...RELAY NOW |
4521 | | // (but if it does not build on our best tip, let the SendMessages loop relay it) |
4522 | 0 | if (!IsInitialBlockDownload() && ActiveTip() == pindex->pprev && m_options.signals) { Branch (4522:9): [True: 0, False: 0]
Branch (4522:38): [True: 0, False: 0]
Branch (4522:70): [True: 0, False: 0]
|
4523 | 0 | m_options.signals->NewPoWValidBlock(pindex, pblock); |
4524 | 0 | } |
4525 | | |
4526 | | // Write block to history file |
4527 | 0 | if (fNewBlock) *fNewBlock = true; Branch (4527:9): [True: 0, False: 0]
|
4528 | 0 | try { |
4529 | 0 | FlatFilePos blockPos{}; |
4530 | 0 | if (dbp) { Branch (4530:13): [True: 0, False: 0]
|
4531 | 0 | blockPos = *dbp; |
4532 | 0 | m_blockman.UpdateBlockInfo(block, pindex->nHeight, blockPos); |
4533 | 0 | } else { |
4534 | 0 | blockPos = m_blockman.SaveBlockToDisk(block, pindex->nHeight); |
4535 | 0 | if (blockPos.IsNull()) { Branch (4535:17): [True: 0, False: 0]
|
4536 | 0 | state.Error(strprintf("%s: Failed to find position to write new block to disk", __func__)); |
4537 | 0 | return false; |
4538 | 0 | } |
4539 | 0 | } |
4540 | 0 | ReceivedBlockTransactions(block, pindex, blockPos); |
4541 | 0 | } catch (const std::runtime_error& e) { |
4542 | 0 | return FatalError(GetNotifications(), state, strprintf(_("System error while saving block to disk: %s"), e.what())); |
4543 | 0 | } |
4544 | | |
4545 | | // TODO: FlushStateToDisk() handles flushing of both block and chainstate |
4546 | | // data, so we should move this to ChainstateManager so that we can be more |
4547 | | // intelligent about how we flush. |
4548 | | // For now, since FlushStateMode::NONE is used, all that can happen is that |
4549 | | // the block files may be pruned, so we can just call this on one |
4550 | | // chainstate (particularly if we haven't implemented pruning with |
4551 | | // background validation yet). |
4552 | 0 | ActiveChainstate().FlushStateToDisk(state, FlushStateMode::NONE); |
4553 | |
|
4554 | 0 | CheckBlockIndex(); |
4555 | |
|
4556 | 0 | return true; |
4557 | 0 | } |
4558 | | |
4559 | | bool ChainstateManager::ProcessNewBlock(const std::shared_ptr<const CBlock>& block, bool force_processing, bool min_pow_checked, bool* new_block) |
4560 | 6.84k | { |
4561 | 6.84k | AssertLockNotHeld(cs_main); |
4562 | | |
4563 | 6.84k | { |
4564 | 6.84k | CBlockIndex *pindex = nullptr; |
4565 | 6.84k | if (new_block) *new_block = false; Branch (4565:13): [True: 6.84k, False: 0]
|
4566 | 6.84k | BlockValidationState state; |
4567 | | |
4568 | | // CheckBlock() does not support multi-threaded block validation because CBlock::fChecked can cause data race. |
4569 | | // Therefore, the following critical section must include the CheckBlock() call as well. |
4570 | 6.84k | LOCK(cs_main); |
4571 | | |
4572 | | // Skipping AcceptBlock() for CheckBlock() failures means that we will never mark a block as invalid if |
4573 | | // CheckBlock() fails. This is protective against consensus failure if there are any unknown forms of block |
4574 | | // malleability that cause CheckBlock() to fail; see e.g. CVE-2012-2459 and |
4575 | | // https://lists.linuxfoundation.org/pipermail/bitcoin-dev/2019-February/016697.html. Because CheckBlock() is |
4576 | | // not very expensive, the anti-DoS benefits of caching failure (of a definitely-invalid block) are not substantial. |
4577 | 6.84k | bool ret = CheckBlock(*block, state, GetConsensus()); |
4578 | 6.84k | if (ret) { Branch (4578:13): [True: 6.84k, False: 0]
|
4579 | | // Store to disk |
4580 | 6.84k | ret = AcceptBlock(block, state, &pindex, force_processing, nullptr, new_block, min_pow_checked); |
4581 | 6.84k | } |
4582 | 6.84k | if (!ret) { Branch (4582:13): [True: 6.84k, False: 0]
|
4583 | 6.84k | if (m_options.signals) { Branch (4583:17): [True: 6.84k, False: 0]
|
4584 | 6.84k | m_options.signals->BlockChecked(*block, state); |
4585 | 6.84k | } |
4586 | 6.84k | LogError("%s: AcceptBlock FAILED (%s)\n", __func__, state.ToString()); |
4587 | 6.84k | return false; |
4588 | 6.84k | } |
4589 | 6.84k | } |
4590 | | |
4591 | 0 | NotifyHeaderTip(); |
4592 | |
|
4593 | 0 | BlockValidationState state; // Only used to report errors, not invalidity - ignore it |
4594 | 0 | if (!ActiveChainstate().ActivateBestChain(state, block)) { Branch (4594:9): [True: 0, False: 0]
|
4595 | 0 | LogError("%s: ActivateBestChain failed (%s)\n", __func__, state.ToString()); |
4596 | 0 | return false; |
4597 | 0 | } |
4598 | | |
4599 | 0 | Chainstate* bg_chain{WITH_LOCK(cs_main, return BackgroundSyncInProgress() ? m_ibd_chainstate.get() : nullptr)}; |
4600 | 0 | BlockValidationState bg_state; |
4601 | 0 | if (bg_chain && !bg_chain->ActivateBestChain(bg_state, block)) { Branch (4601:9): [True: 0, False: 0]
Branch (4601:9): [True: 0, False: 0]
Branch (4601:21): [True: 0, False: 0]
|
4602 | 0 | LogError("%s: [background] ActivateBestChain failed (%s)\n", __func__, bg_state.ToString()); |
4603 | 0 | return false; |
4604 | 0 | } |
4605 | | |
4606 | 0 | return true; |
4607 | 0 | } |
4608 | | |
4609 | | MempoolAcceptResult ChainstateManager::ProcessTransaction(const CTransactionRef& tx, bool test_accept) |
4610 | 0 | { |
4611 | 0 | AssertLockHeld(cs_main); |
4612 | 0 | Chainstate& active_chainstate = ActiveChainstate(); |
4613 | 0 | if (!active_chainstate.GetMempool()) { Branch (4613:9): [True: 0, False: 0]
|
4614 | 0 | TxValidationState state; |
4615 | 0 | state.Invalid(TxValidationResult::TX_NO_MEMPOOL, "no-mempool"); |
4616 | 0 | return MempoolAcceptResult::Failure(state); |
4617 | 0 | } |
4618 | 0 | auto result = AcceptToMemoryPool(active_chainstate, tx, GetTime(), /*bypass_limits=*/ false, test_accept); |
4619 | 0 | active_chainstate.GetMempool()->check(active_chainstate.CoinsTip(), active_chainstate.m_chain.Height() + 1); |
4620 | 0 | return result; |
4621 | 0 | } |
4622 | | |
4623 | | bool TestBlockValidity(BlockValidationState& state, |
4624 | | const CChainParams& chainparams, |
4625 | | Chainstate& chainstate, |
4626 | | const CBlock& block, |
4627 | | CBlockIndex* pindexPrev, |
4628 | | bool fCheckPOW, |
4629 | | bool fCheckMerkleRoot) |
4630 | 0 | { |
4631 | 0 | AssertLockHeld(cs_main); |
4632 | 0 | assert(pindexPrev && pindexPrev == chainstate.m_chain.Tip()); |
4633 | 0 | CCoinsViewCache viewNew(&chainstate.CoinsTip()); |
4634 | 0 | uint256 block_hash(block.GetHash()); |
4635 | 0 | CBlockIndex indexDummy(block); |
4636 | 0 | indexDummy.pprev = pindexPrev; |
4637 | 0 | indexDummy.nHeight = pindexPrev->nHeight + 1; |
4638 | 0 | indexDummy.phashBlock = &block_hash; |
4639 | | |
4640 | | // NOTE: CheckBlockHeader is called by CheckBlock |
4641 | 0 | if (!ContextualCheckBlockHeader(block, state, chainstate.m_blockman, chainstate.m_chainman, pindexPrev)) { Branch (4641:9): [True: 0, False: 0]
|
4642 | 0 | LogError("%s: Consensus::ContextualCheckBlockHeader: %s\n", __func__, state.ToString()); |
4643 | 0 | return false; |
4644 | 0 | } |
4645 | 0 | if (!CheckBlock(block, state, chainparams.GetConsensus(), fCheckPOW, fCheckMerkleRoot)) { Branch (4645:9): [True: 0, False: 0]
|
4646 | 0 | LogError("%s: Consensus::CheckBlock: %s\n", __func__, state.ToString()); |
4647 | 0 | return false; |
4648 | 0 | } |
4649 | 0 | if (!ContextualCheckBlock(block, state, chainstate.m_chainman, pindexPrev)) { Branch (4649:9): [True: 0, False: 0]
|
4650 | 0 | LogError("%s: Consensus::ContextualCheckBlock: %s\n", __func__, state.ToString()); |
4651 | 0 | return false; |
4652 | 0 | } |
4653 | 0 | if (!chainstate.ConnectBlock(block, state, &indexDummy, viewNew, true)) { Branch (4653:9): [True: 0, False: 0]
|
4654 | 0 | return false; |
4655 | 0 | } |
4656 | 0 | assert(state.IsValid()); |
4657 | | |
4658 | 0 | return true; |
4659 | 0 | } |
4660 | | |
4661 | | /* This function is called from the RPC code for pruneblockchain */ |
4662 | | void PruneBlockFilesManual(Chainstate& active_chainstate, int nManualPruneHeight) |
4663 | 0 | { |
4664 | 0 | BlockValidationState state; |
4665 | 0 | if (!active_chainstate.FlushStateToDisk( Branch (4665:9): [True: 0, False: 0]
|
4666 | 0 | state, FlushStateMode::NONE, nManualPruneHeight)) { |
4667 | 0 | LogPrintf("%s: failed to flush state (%s)\n", __func__, state.ToString()); |
4668 | 0 | } |
4669 | 0 | } |
4670 | | |
4671 | | bool Chainstate::LoadChainTip() |
4672 | 0 | { |
4673 | 0 | AssertLockHeld(cs_main); |
4674 | 0 | const CCoinsViewCache& coins_cache = CoinsTip(); |
4675 | 0 | assert(!coins_cache.GetBestBlock().IsNull()); // Never called when the coins view is empty |
4676 | 0 | const CBlockIndex* tip = m_chain.Tip(); |
4677 | |
|
4678 | 0 | if (tip && tip->GetBlockHash() == coins_cache.GetBestBlock()) { Branch (4678:9): [True: 0, False: 0]
Branch (4678:9): [True: 0, False: 0]
Branch (4678:16): [True: 0, False: 0]
|
4679 | 0 | return true; |
4680 | 0 | } |
4681 | | |
4682 | | // Load pointer to end of best chain |
4683 | 0 | CBlockIndex* pindex = m_blockman.LookupBlockIndex(coins_cache.GetBestBlock()); |
4684 | 0 | if (!pindex) { Branch (4684:9): [True: 0, False: 0]
|
4685 | 0 | return false; |
4686 | 0 | } |
4687 | 0 | m_chain.SetTip(*pindex); |
4688 | 0 | PruneBlockIndexCandidates(); |
4689 | |
|
4690 | 0 | tip = m_chain.Tip(); |
4691 | 0 | LogPrintf("Loaded best chain: hashBestChain=%s height=%d date=%s progress=%f\n", |
4692 | 0 | tip->GetBlockHash().ToString(), |
4693 | 0 | m_chain.Height(), |
4694 | 0 | FormatISO8601DateTime(tip->GetBlockTime()), |
4695 | 0 | GuessVerificationProgress(m_chainman.GetParams().TxData(), tip)); |
4696 | 0 | return true; |
4697 | 0 | } |
4698 | | |
4699 | | CVerifyDB::CVerifyDB(Notifications& notifications) |
4700 | 0 | : m_notifications{notifications} |
4701 | 0 | { |
4702 | 0 | m_notifications.progress(_("Verifying blocks…"), 0, false); |
4703 | 0 | } |
4704 | | |
4705 | | CVerifyDB::~CVerifyDB() |
4706 | 0 | { |
4707 | 0 | m_notifications.progress(bilingual_str{}, 100, false); |
4708 | 0 | } |
4709 | | |
4710 | | VerifyDBResult CVerifyDB::VerifyDB( |
4711 | | Chainstate& chainstate, |
4712 | | const Consensus::Params& consensus_params, |
4713 | | CCoinsView& coinsview, |
4714 | | int nCheckLevel, int nCheckDepth) |
4715 | 0 | { |
4716 | 0 | AssertLockHeld(cs_main); |
4717 | |
|
4718 | 0 | if (chainstate.m_chain.Tip() == nullptr || chainstate.m_chain.Tip()->pprev == nullptr) { Branch (4718:9): [True: 0, False: 0]
Branch (4718:48): [True: 0, False: 0]
|
4719 | 0 | return VerifyDBResult::SUCCESS; |
4720 | 0 | } |
4721 | | |
4722 | | // Verify blocks in the best chain |
4723 | 0 | if (nCheckDepth <= 0 || nCheckDepth > chainstate.m_chain.Height()) { Branch (4723:9): [True: 0, False: 0]
Branch (4723:29): [True: 0, False: 0]
|
4724 | 0 | nCheckDepth = chainstate.m_chain.Height(); |
4725 | 0 | } |
4726 | 0 | nCheckLevel = std::max(0, std::min(4, nCheckLevel)); |
4727 | 0 | LogPrintf("Verifying last %i blocks at level %i\n", nCheckDepth, nCheckLevel); |
4728 | 0 | CCoinsViewCache coins(&coinsview); |
4729 | 0 | CBlockIndex* pindex; |
4730 | 0 | CBlockIndex* pindexFailure = nullptr; |
4731 | 0 | int nGoodTransactions = 0; |
4732 | 0 | BlockValidationState state; |
4733 | 0 | int reportDone = 0; |
4734 | 0 | bool skipped_no_block_data{false}; |
4735 | 0 | bool skipped_l3_checks{false}; |
4736 | 0 | LogPrintf("Verification progress: 0%%\n"); |
4737 | |
|
4738 | 0 | const bool is_snapshot_cs{chainstate.m_from_snapshot_blockhash}; |
4739 | |
|
4740 | 0 | for (pindex = chainstate.m_chain.Tip(); pindex && pindex->pprev; pindex = pindex->pprev) { Branch (4740:45): [True: 0, False: 0]
Branch (4740:55): [True: 0, False: 0]
|
4741 | 0 | const int percentageDone = std::max(1, std::min(99, (int)(((double)(chainstate.m_chain.Height() - pindex->nHeight)) / (double)nCheckDepth * (nCheckLevel >= 4 ? 50 : 100)))); |
4742 | 0 | if (reportDone < percentageDone / 10) { Branch (4742:13): [True: 0, False: 0]
|
4743 | | // report every 10% step |
4744 | 0 | LogPrintf("Verification progress: %d%%\n", percentageDone); |
4745 | 0 | reportDone = percentageDone / 10; |
4746 | 0 | } |
4747 | 0 | m_notifications.progress(_("Verifying blocks…"), percentageDone, false); |
4748 | 0 | if (pindex->nHeight <= chainstate.m_chain.Height() - nCheckDepth) { Branch (4748:13): [True: 0, False: 0]
|
4749 | 0 | break; |
4750 | 0 | } |
4751 | 0 | if ((chainstate.m_blockman.IsPruneMode() || is_snapshot_cs) && !(pindex->nStatus & BLOCK_HAVE_DATA)) { Branch (4751:14): [True: 0, False: 0]
Branch (4751:53): [True: 0, False: 0]
Branch (4751:72): [True: 0, False: 0]
|
4752 | | // If pruning or running under an assumeutxo snapshot, only go |
4753 | | // back as far as we have data. |
4754 | 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); |
4755 | 0 | skipped_no_block_data = true; |
4756 | 0 | break; |
4757 | 0 | } |
4758 | 0 | CBlock block; |
4759 | | // check level 0: read from disk |
4760 | 0 | if (!chainstate.m_blockman.ReadBlockFromDisk(block, *pindex)) { Branch (4760:13): [True: 0, False: 0]
|
4761 | 0 | LogPrintf("Verification error: ReadBlockFromDisk failed at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString()); |
4762 | 0 | return VerifyDBResult::CORRUPTED_BLOCK_DB; |
4763 | 0 | } |
4764 | | // check level 1: verify block validity |
4765 | 0 | if (nCheckLevel >= 1 && !CheckBlock(block, state, consensus_params)) { Branch (4765:13): [True: 0, False: 0]
Branch (4765:33): [True: 0, False: 0]
|
4766 | 0 | LogPrintf("Verification error: found bad block at %d, hash=%s (%s)\n", |
4767 | 0 | pindex->nHeight, pindex->GetBlockHash().ToString(), state.ToString()); |
4768 | 0 | return VerifyDBResult::CORRUPTED_BLOCK_DB; |
4769 | 0 | } |
4770 | | // check level 2: verify undo validity |
4771 | 0 | if (nCheckLevel >= 2 && pindex) { Branch (4771:13): [True: 0, False: 0]
Branch (4771:33): [True: 0, False: 0]
|
4772 | 0 | CBlockUndo undo; |
4773 | 0 | if (!pindex->GetUndoPos().IsNull()) { Branch (4773:17): [True: 0, False: 0]
|
4774 | 0 | if (!chainstate.m_blockman.UndoReadFromDisk(undo, *pindex)) { Branch (4774:21): [True: 0, False: 0]
|
4775 | 0 | LogPrintf("Verification error: found bad undo data at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString()); |
4776 | 0 | return VerifyDBResult::CORRUPTED_BLOCK_DB; |
4777 | 0 | } |
4778 | 0 | } |
4779 | 0 | } |
4780 | | // check level 3: check for inconsistencies during memory-only disconnect of tip blocks |
4781 | 0 | size_t curr_coins_usage = coins.DynamicMemoryUsage() + chainstate.CoinsTip().DynamicMemoryUsage(); |
4782 | |
|
4783 | 0 | if (nCheckLevel >= 3) { Branch (4783:13): [True: 0, False: 0]
|
4784 | 0 | if (curr_coins_usage <= chainstate.m_coinstip_cache_size_bytes) { Branch (4784:17): [True: 0, False: 0]
|
4785 | 0 | assert(coins.GetBestBlock() == pindex->GetBlockHash()); |
4786 | 0 | DisconnectResult res = chainstate.DisconnectBlock(block, pindex, coins); |
4787 | 0 | if (res == DISCONNECT_FAILED) { Branch (4787:21): [True: 0, False: 0]
|
4788 | 0 | LogPrintf("Verification error: irrecoverable inconsistency in block data at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString()); |
4789 | 0 | return VerifyDBResult::CORRUPTED_BLOCK_DB; |
4790 | 0 | } |
4791 | 0 | if (res == DISCONNECT_UNCLEAN) { Branch (4791:21): [True: 0, False: 0]
|
4792 | 0 | nGoodTransactions = 0; |
4793 | 0 | pindexFailure = pindex; |
4794 | 0 | } else { |
4795 | 0 | nGoodTransactions += block.vtx.size(); |
4796 | 0 | } |
4797 | 0 | } else { |
4798 | 0 | skipped_l3_checks = true; |
4799 | 0 | } |
4800 | 0 | } |
4801 | 0 | if (chainstate.m_chainman.m_interrupt) return VerifyDBResult::INTERRUPTED; Branch (4801:13): [True: 0, False: 0]
|
4802 | 0 | } |
4803 | 0 | if (pindexFailure) { Branch (4803:9): [True: 0, False: 0]
|
4804 | 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); |
4805 | 0 | return VerifyDBResult::CORRUPTED_BLOCK_DB; |
4806 | 0 | } |
4807 | 0 | if (skipped_l3_checks) { Branch (4807:9): [True: 0, False: 0]
|
4808 | 0 | LogPrintf("Skipped verification of level >=3 (insufficient database cache size). Consider increasing -dbcache.\n"); |
4809 | 0 | } |
4810 | | |
4811 | | // store block count as we move pindex at check level >= 4 |
4812 | 0 | int block_count = chainstate.m_chain.Height() - pindex->nHeight; |
4813 | | |
4814 | | // check level 4: try reconnecting blocks |
4815 | 0 | if (nCheckLevel >= 4 && !skipped_l3_checks) { Branch (4815:9): [True: 0, False: 0]
Branch (4815:29): [True: 0, False: 0]
|
4816 | 0 | while (pindex != chainstate.m_chain.Tip()) { Branch (4816:16): [True: 0, False: 0]
|
4817 | 0 | const int percentageDone = std::max(1, std::min(99, 100 - (int)(((double)(chainstate.m_chain.Height() - pindex->nHeight)) / (double)nCheckDepth * 50))); |
4818 | 0 | if (reportDone < percentageDone / 10) { Branch (4818:17): [True: 0, False: 0]
|
4819 | | // report every 10% step |
4820 | 0 | LogPrintf("Verification progress: %d%%\n", percentageDone); |
4821 | 0 | reportDone = percentageDone / 10; |
4822 | 0 | } |
4823 | 0 | m_notifications.progress(_("Verifying blocks…"), percentageDone, false); |
4824 | 0 | pindex = chainstate.m_chain.Next(pindex); |
4825 | 0 | CBlock block; |
4826 | 0 | if (!chainstate.m_blockman.ReadBlockFromDisk(block, *pindex)) { Branch (4826:17): [True: 0, False: 0]
|
4827 | 0 | LogPrintf("Verification error: ReadBlockFromDisk failed at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString()); |
4828 | 0 | return VerifyDBResult::CORRUPTED_BLOCK_DB; |
4829 | 0 | } |
4830 | 0 | if (!chainstate.ConnectBlock(block, state, pindex, coins)) { Branch (4830:17): [True: 0, False: 0]
|
4831 | 0 | LogPrintf("Verification error: found unconnectable block at %d, hash=%s (%s)\n", pindex->nHeight, pindex->GetBlockHash().ToString(), state.ToString()); |
4832 | 0 | return VerifyDBResult::CORRUPTED_BLOCK_DB; |
4833 | 0 | } |
4834 | 0 | if (chainstate.m_chainman.m_interrupt) return VerifyDBResult::INTERRUPTED; Branch (4834:17): [True: 0, False: 0]
|
4835 | 0 | } |
4836 | 0 | } |
4837 | | |
4838 | 0 | LogPrintf("Verification: No coin database inconsistencies in last %i blocks (%i transactions)\n", block_count, nGoodTransactions); |
4839 | |
|
4840 | 0 | if (skipped_l3_checks) { Branch (4840:9): [True: 0, False: 0]
|
4841 | 0 | return VerifyDBResult::SKIPPED_L3_CHECKS; |
4842 | 0 | } |
4843 | 0 | if (skipped_no_block_data) { Branch (4843:9): [True: 0, False: 0]
|
4844 | 0 | return VerifyDBResult::SKIPPED_MISSING_BLOCKS; |
4845 | 0 | } |
4846 | 0 | return VerifyDBResult::SUCCESS; |
4847 | 0 | } |
4848 | | |
4849 | | /** Apply the effects of a block on the utxo cache, ignoring that it may already have been applied. */ |
4850 | | bool Chainstate::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& inputs) |
4851 | 0 | { |
4852 | 0 | AssertLockHeld(cs_main); |
4853 | | // TODO: merge with ConnectBlock |
4854 | 0 | CBlock block; |
4855 | 0 | if (!m_blockman.ReadBlockFromDisk(block, *pindex)) { Branch (4855:9): [True: 0, False: 0]
|
4856 | 0 | LogError("ReplayBlock(): ReadBlockFromDisk failed at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString()); |
4857 | 0 | return false; |
4858 | 0 | } |
4859 | | |
4860 | 0 | for (const CTransactionRef& tx : block.vtx) { Branch (4860:36): [True: 0, False: 0]
|
4861 | 0 | if (!tx->IsCoinBase()) { Branch (4861:13): [True: 0, False: 0]
|
4862 | 0 | for (const CTxIn &txin : tx->vin) { Branch (4862:36): [True: 0, False: 0]
|
4863 | 0 | inputs.SpendCoin(txin.prevout); |
4864 | 0 | } |
4865 | 0 | } |
4866 | | // Pass check = true as every addition may be an overwrite. |
4867 | 0 | AddCoins(inputs, *tx, pindex->nHeight, true); |
4868 | 0 | } |
4869 | 0 | return true; |
4870 | 0 | } |
4871 | | |
4872 | | bool Chainstate::ReplayBlocks() |
4873 | 0 | { |
4874 | 0 | LOCK(cs_main); |
4875 | |
|
4876 | 0 | CCoinsView& db = this->CoinsDB(); |
4877 | 0 | CCoinsViewCache cache(&db); |
4878 | |
|
4879 | 0 | std::vector<uint256> hashHeads = db.GetHeadBlocks(); |
4880 | 0 | if (hashHeads.empty()) return true; // We're already in a consistent state. Branch (4880:9): [True: 0, False: 0]
|
4881 | 0 | if (hashHeads.size() != 2) { Branch (4881:9): [True: 0, False: 0]
|
4882 | 0 | LogError("ReplayBlocks(): unknown inconsistent state\n"); |
4883 | 0 | return false; |
4884 | 0 | } |
4885 | | |
4886 | 0 | m_chainman.GetNotifications().progress(_("Replaying blocks…"), 0, false); |
4887 | 0 | LogPrintf("Replaying blocks\n"); |
4888 | |
|
4889 | 0 | const CBlockIndex* pindexOld = nullptr; // Old tip during the interrupted flush. |
4890 | 0 | const CBlockIndex* pindexNew; // New tip during the interrupted flush. |
4891 | 0 | const CBlockIndex* pindexFork = nullptr; // Latest block common to both the old and the new tip. |
4892 | |
|
4893 | 0 | if (m_blockman.m_block_index.count(hashHeads[0]) == 0) { Branch (4893:9): [True: 0, False: 0]
|
4894 | 0 | LogError("ReplayBlocks(): reorganization to unknown block requested\n"); |
4895 | 0 | return false; |
4896 | 0 | } |
4897 | 0 | pindexNew = &(m_blockman.m_block_index[hashHeads[0]]); |
4898 | |
|
4899 | 0 | if (!hashHeads[1].IsNull()) { // The old tip is allowed to be 0, indicating it's the first flush. Branch (4899:9): [True: 0, False: 0]
|
4900 | 0 | if (m_blockman.m_block_index.count(hashHeads[1]) == 0) { Branch (4900:13): [True: 0, False: 0]
|
4901 | 0 | LogError("ReplayBlocks(): reorganization from unknown block requested\n"); |
4902 | 0 | return false; |
4903 | 0 | } |
4904 | 0 | pindexOld = &(m_blockman.m_block_index[hashHeads[1]]); |
4905 | 0 | pindexFork = LastCommonAncestor(pindexOld, pindexNew); |
4906 | 0 | assert(pindexFork != nullptr); |
4907 | 0 | } |
4908 | | |
4909 | | // Rollback along the old branch. |
4910 | 0 | while (pindexOld != pindexFork) { Branch (4910:12): [True: 0, False: 0]
|
4911 | 0 | if (pindexOld->nHeight > 0) { // Never disconnect the genesis block. Branch (4911:13): [True: 0, False: 0]
|
4912 | 0 | CBlock block; |
4913 | 0 | if (!m_blockman.ReadBlockFromDisk(block, *pindexOld)) { Branch (4913:17): [True: 0, False: 0]
|
4914 | 0 | LogError("RollbackBlock(): ReadBlockFromDisk() failed at %d, hash=%s\n", pindexOld->nHeight, pindexOld->GetBlockHash().ToString()); |
4915 | 0 | return false; |
4916 | 0 | } |
4917 | 0 | LogPrintf("Rolling back %s (%i)\n", pindexOld->GetBlockHash().ToString(), pindexOld->nHeight); |
4918 | 0 | DisconnectResult res = DisconnectBlock(block, pindexOld, cache); |
4919 | 0 | if (res == DISCONNECT_FAILED) { Branch (4919:17): [True: 0, False: 0]
|
4920 | 0 | LogError("RollbackBlock(): DisconnectBlock failed at %d, hash=%s\n", pindexOld->nHeight, pindexOld->GetBlockHash().ToString()); |
4921 | 0 | return false; |
4922 | 0 | } |
4923 | | // If DISCONNECT_UNCLEAN is returned, it means a non-existing UTXO was deleted, or an existing UTXO was |
4924 | | // overwritten. It corresponds to cases where the block-to-be-disconnect never had all its operations |
4925 | | // applied to the UTXO set. However, as both writing a UTXO and deleting a UTXO are idempotent operations, |
4926 | | // the result is still a version of the UTXO set with the effects of that block undone. |
4927 | 0 | } |
4928 | 0 | pindexOld = pindexOld->pprev; |
4929 | 0 | } |
4930 | | |
4931 | | // Roll forward from the forking point to the new tip. |
4932 | 0 | int nForkHeight = pindexFork ? pindexFork->nHeight : 0; Branch (4932:23): [True: 0, False: 0]
|
4933 | 0 | for (int nHeight = nForkHeight + 1; nHeight <= pindexNew->nHeight; ++nHeight) { Branch (4933:41): [True: 0, False: 0]
|
4934 | 0 | const CBlockIndex& pindex{*Assert(pindexNew->GetAncestor(nHeight))}; |
4935 | |
|
4936 | 0 | LogPrintf("Rolling forward %s (%i)\n", pindex.GetBlockHash().ToString(), nHeight); |
4937 | 0 | m_chainman.GetNotifications().progress(_("Replaying blocks…"), (int)((nHeight - nForkHeight) * 100.0 / (pindexNew->nHeight - nForkHeight)), false); |
4938 | 0 | if (!RollforwardBlock(&pindex, cache)) return false; Branch (4938:13): [True: 0, False: 0]
|
4939 | 0 | } |
4940 | | |
4941 | 0 | cache.SetBestBlock(pindexNew->GetBlockHash()); |
4942 | 0 | cache.Flush(); |
4943 | 0 | m_chainman.GetNotifications().progress(bilingual_str{}, 100, false); |
4944 | 0 | return true; |
4945 | 0 | } |
4946 | | |
4947 | | bool Chainstate::NeedsRedownload() const |
4948 | 0 | { |
4949 | 0 | AssertLockHeld(cs_main); |
4950 | | |
4951 | | // At and above m_params.SegwitHeight, segwit consensus rules must be validated |
4952 | 0 | CBlockIndex* block{m_chain.Tip()}; |
4953 | |
|
4954 | 0 | while (block != nullptr && DeploymentActiveAt(*block, m_chainman, Consensus::DEPLOYMENT_SEGWIT)) { Branch (4954:12): [True: 0, False: 0]
Branch (4954:32): [True: 0, False: 0]
|
4955 | 0 | if (!(block->nStatus & BLOCK_OPT_WITNESS)) { Branch (4955:13): [True: 0, False: 0]
|
4956 | | // block is insufficiently validated for a segwit client |
4957 | 0 | return true; |
4958 | 0 | } |
4959 | 0 | block = block->pprev; |
4960 | 0 | } |
4961 | | |
4962 | 0 | return false; |
4963 | 0 | } |
4964 | | |
4965 | | void Chainstate::ClearBlockIndexCandidates() |
4966 | 0 | { |
4967 | 0 | AssertLockHeld(::cs_main); |
4968 | 0 | setBlockIndexCandidates.clear(); |
4969 | 0 | } |
4970 | | |
4971 | | bool ChainstateManager::LoadBlockIndex() |
4972 | 0 | { |
4973 | 0 | AssertLockHeld(cs_main); |
4974 | | // Load block index from databases |
4975 | 0 | if (m_blockman.m_blockfiles_indexed) { Branch (4975:9): [True: 0, False: 0]
|
4976 | 0 | bool ret{m_blockman.LoadBlockIndexDB(SnapshotBlockhash())}; |
4977 | 0 | if (!ret) return false; Branch (4977:13): [True: 0, False: 0]
|
4978 | | |
4979 | 0 | m_blockman.ScanAndUnlinkAlreadyPrunedFiles(); |
4980 | |
|
4981 | 0 | std::vector<CBlockIndex*> vSortedByHeight{m_blockman.GetAllBlockIndices()}; |
4982 | 0 | std::sort(vSortedByHeight.begin(), vSortedByHeight.end(), |
4983 | 0 | CBlockIndexHeightOnlyComparator()); |
4984 | |
|
4985 | 0 | for (CBlockIndex* pindex : vSortedByHeight) { Branch (4985:34): [True: 0, False: 0]
|
4986 | 0 | if (m_interrupt) return false; Branch (4986:17): [True: 0, False: 0]
|
4987 | | // If we have an assumeutxo-based chainstate, then the snapshot |
4988 | | // block will be a candidate for the tip, but it may not be |
4989 | | // VALID_TRANSACTIONS (eg if we haven't yet downloaded the block), |
4990 | | // so we special-case the snapshot block as a potential candidate |
4991 | | // here. |
4992 | 0 | if (pindex == GetSnapshotBaseBlock() || Branch (4992:17): [True: 0, False: 0]
|
4993 | 0 | (pindex->IsValid(BLOCK_VALID_TRANSACTIONS) && Branch (4993:22): [True: 0, False: 0]
|
4994 | 0 | (pindex->HaveNumChainTxs() || pindex->pprev == nullptr))) { Branch (4994:23): [True: 0, False: 0]
Branch (4994:52): [True: 0, False: 0]
|
4995 | |
|
4996 | 0 | for (Chainstate* chainstate : GetAll()) { Branch (4996:45): [True: 0, False: 0]
|
4997 | 0 | chainstate->TryAddBlockIndexCandidate(pindex); |
4998 | 0 | } |
4999 | 0 | } |
5000 | 0 | if (pindex->nStatus & BLOCK_FAILED_MASK && (!m_best_invalid || pindex->nChainWork > m_best_invalid->nChainWork)) { Branch (5000:17): [True: 0, False: 0]
Branch (5000:57): [True: 0, False: 0]
Branch (5000:76): [True: 0, False: 0]
|
5001 | 0 | m_best_invalid = pindex; |
5002 | 0 | } |
5003 | 0 | if (pindex->IsValid(BLOCK_VALID_TREE) && (m_best_header == nullptr || CBlockIndexWorkComparator()(m_best_header, pindex))) Branch (5003:17): [True: 0, False: 0]
Branch (5003:17): [True: 0, False: 0]
Branch (5003:55): [True: 0, False: 0]
Branch (5003:83): [True: 0, False: 0]
|
5004 | 0 | m_best_header = pindex; |
5005 | 0 | } |
5006 | 0 | } |
5007 | 0 | return true; |
5008 | 0 | } |
5009 | | |
5010 | | bool Chainstate::LoadGenesisBlock() |
5011 | 0 | { |
5012 | 0 | LOCK(cs_main); |
5013 | |
|
5014 | 0 | const CChainParams& params{m_chainman.GetParams()}; |
5015 | | |
5016 | | // Check whether we're already initialized by checking for genesis in |
5017 | | // m_blockman.m_block_index. Note that we can't use m_chain here, since it is |
5018 | | // set based on the coins db, not the block index db, which is the only |
5019 | | // thing loaded at this point. |
5020 | 0 | if (m_blockman.m_block_index.count(params.GenesisBlock().GetHash())) Branch (5020:9): [True: 0, False: 0]
|
5021 | 0 | return true; |
5022 | | |
5023 | 0 | try { |
5024 | 0 | const CBlock& block = params.GenesisBlock(); |
5025 | 0 | FlatFilePos blockPos{m_blockman.SaveBlockToDisk(block, 0)}; |
5026 | 0 | if (blockPos.IsNull()) { Branch (5026:13): [True: 0, False: 0]
|
5027 | 0 | LogError("%s: writing genesis block to disk failed\n", __func__); |
5028 | 0 | return false; |
5029 | 0 | } |
5030 | 0 | CBlockIndex* pindex = m_blockman.AddToBlockIndex(block, m_chainman.m_best_header); |
5031 | 0 | m_chainman.ReceivedBlockTransactions(block, pindex, blockPos); |
5032 | 0 | } catch (const std::runtime_error& e) { |
5033 | 0 | LogError("%s: failed to write genesis block: %s\n", __func__, e.what()); |
5034 | 0 | return false; |
5035 | 0 | } |
5036 | | |
5037 | 0 | return true; |
5038 | 0 | } |
5039 | | |
5040 | | void ChainstateManager::LoadExternalBlockFile( |
5041 | | AutoFile& file_in, |
5042 | | FlatFilePos* dbp, |
5043 | | std::multimap<uint256, FlatFilePos>* blocks_with_unknown_parent) |
5044 | 0 | { |
5045 | | // Either both should be specified (-reindex), or neither (-loadblock). |
5046 | 0 | assert(!dbp == !blocks_with_unknown_parent); |
5047 | | |
5048 | 0 | const auto start{SteadyClock::now()}; |
5049 | 0 | const CChainParams& params{GetParams()}; |
5050 | |
|
5051 | 0 | int nLoaded = 0; |
5052 | 0 | try { |
5053 | 0 | BufferedFile blkdat{file_in, 2 * MAX_BLOCK_SERIALIZED_SIZE, MAX_BLOCK_SERIALIZED_SIZE + 8}; |
5054 | | // nRewind indicates where to resume scanning in case something goes wrong, |
5055 | | // such as a block fails to deserialize. |
5056 | 0 | uint64_t nRewind = blkdat.GetPos(); |
5057 | 0 | while (!blkdat.eof()) { Branch (5057:16): [True: 0, False: 0]
|
5058 | 0 | if (m_interrupt) return; Branch (5058:17): [True: 0, False: 0]
|
5059 | | |
5060 | 0 | blkdat.SetPos(nRewind); |
5061 | 0 | nRewind++; // start one byte further next time, in case of failure |
5062 | 0 | blkdat.SetLimit(); // remove former limit |
5063 | 0 | unsigned int nSize = 0; |
5064 | 0 | try { |
5065 | | // locate a header |
5066 | 0 | MessageStartChars buf; |
5067 | 0 | blkdat.FindByte(std::byte(params.MessageStart()[0])); |
5068 | 0 | nRewind = blkdat.GetPos() + 1; |
5069 | 0 | blkdat >> buf; |
5070 | 0 | if (buf != params.MessageStart()) { Branch (5070:21): [True: 0, False: 0]
|
5071 | 0 | continue; |
5072 | 0 | } |
5073 | | // read size |
5074 | 0 | blkdat >> nSize; |
5075 | 0 | if (nSize < 80 || nSize > MAX_BLOCK_SERIALIZED_SIZE) Branch (5075:21): [True: 0, False: 0]
Branch (5075:35): [True: 0, False: 0]
|
5076 | 0 | continue; |
5077 | 0 | } catch (const std::exception&) { |
5078 | | // no valid block header found; don't complain |
5079 | | // (this happens at the end of every blk.dat file) |
5080 | 0 | break; |
5081 | 0 | } |
5082 | 0 | try { |
5083 | | // read block header |
5084 | 0 | const uint64_t nBlockPos{blkdat.GetPos()}; |
5085 | 0 | if (dbp) Branch (5085:21): [True: 0, False: 0]
|
5086 | 0 | dbp->nPos = nBlockPos; |
5087 | 0 | blkdat.SetLimit(nBlockPos + nSize); |
5088 | 0 | CBlockHeader header; |
5089 | 0 | blkdat >> header; |
5090 | 0 | const uint256 hash{header.GetHash()}; |
5091 | | // Skip the rest of this block (this may read from disk into memory); position to the marker before the |
5092 | | // next block, but it's still possible to rewind to the start of the current block (without a disk read). |
5093 | 0 | nRewind = nBlockPos + nSize; |
5094 | 0 | blkdat.SkipTo(nRewind); |
5095 | |
|
5096 | 0 | std::shared_ptr<CBlock> pblock{}; // needs to remain available after the cs_main lock is released to avoid duplicate reads from disk |
5097 | |
|
5098 | 0 | { |
5099 | 0 | LOCK(cs_main); |
5100 | | // detect out of order blocks, and store them for later |
5101 | 0 | if (hash != params.GetConsensus().hashGenesisBlock && !m_blockman.LookupBlockIndex(header.hashPrevBlock)) { Branch (5101:25): [True: 0, False: 0]
Branch (5101:75): [True: 0, False: 0]
|
5102 | 0 | LogPrint(BCLog::REINDEX, "%s: Out of order block %s, parent %s not known\n", __func__, hash.ToString(), |
5103 | 0 | header.hashPrevBlock.ToString()); |
5104 | 0 | if (dbp && blocks_with_unknown_parent) { Branch (5104:29): [True: 0, False: 0]
Branch (5104:36): [True: 0, False: 0]
|
5105 | 0 | blocks_with_unknown_parent->emplace(header.hashPrevBlock, *dbp); |
5106 | 0 | } |
5107 | 0 | continue; |
5108 | 0 | } |
5109 | | |
5110 | | // process in case the block isn't known yet |
5111 | 0 | const CBlockIndex* pindex = m_blockman.LookupBlockIndex(hash); |
5112 | 0 | if (!pindex || (pindex->nStatus & BLOCK_HAVE_DATA) == 0) { Branch (5112:25): [True: 0, False: 0]
Branch (5112:36): [True: 0, False: 0]
|
5113 | | // This block can be processed immediately; rewind to its start, read and deserialize it. |
5114 | 0 | blkdat.SetPos(nBlockPos); |
5115 | 0 | pblock = std::make_shared<CBlock>(); |
5116 | 0 | blkdat >> TX_WITH_WITNESS(*pblock); |
5117 | 0 | nRewind = blkdat.GetPos(); |
5118 | |
|
5119 | 0 | BlockValidationState state; |
5120 | 0 | if (AcceptBlock(pblock, state, nullptr, true, dbp, nullptr, true)) { Branch (5120:29): [True: 0, False: 0]
|
5121 | 0 | nLoaded++; |
5122 | 0 | } |
5123 | 0 | if (state.IsError()) { Branch (5123:29): [True: 0, False: 0]
|
5124 | 0 | break; |
5125 | 0 | } |
5126 | 0 | } else if (hash != params.GetConsensus().hashGenesisBlock && pindex->nHeight % 1000 == 0) { Branch (5126:32): [True: 0, False: 0]
Branch (5126:82): [True: 0, False: 0]
|
5127 | 0 | LogPrint(BCLog::REINDEX, "Block Import: already had block %s at height %d\n", hash.ToString(), pindex->nHeight); |
5128 | 0 | } |
5129 | 0 | } |
5130 | | |
5131 | | // Activate the genesis block so normal node progress can continue |
5132 | 0 | if (hash == params.GetConsensus().hashGenesisBlock) { Branch (5132:21): [True: 0, False: 0]
|
5133 | 0 | bool genesis_activation_failure = false; |
5134 | 0 | for (auto c : GetAll()) { Branch (5134:33): [True: 0, False: 0]
|
5135 | 0 | BlockValidationState state; |
5136 | 0 | if (!c->ActivateBestChain(state, nullptr)) { Branch (5136:29): [True: 0, False: 0]
|
5137 | 0 | genesis_activation_failure = true; |
5138 | 0 | break; |
5139 | 0 | } |
5140 | 0 | } |
5141 | 0 | if (genesis_activation_failure) { Branch (5141:25): [True: 0, False: 0]
|
5142 | 0 | break; |
5143 | 0 | } |
5144 | 0 | } |
5145 | | |
5146 | 0 | if (m_blockman.IsPruneMode() && m_blockman.m_blockfiles_indexed && pblock) { Branch (5146:21): [True: 0, False: 0]
Branch (5146:49): [True: 0, False: 0]
Branch (5146:84): [True: 0, False: 0]
|
5147 | | // must update the tip for pruning to work while importing with -loadblock. |
5148 | | // this is a tradeoff to conserve disk space at the expense of time |
5149 | | // spent updating the tip to be able to prune. |
5150 | | // otherwise, ActivateBestChain won't be called by the import process |
5151 | | // until after all of the block files are loaded. ActivateBestChain can be |
5152 | | // called by concurrent network message processing. but, that is not |
5153 | | // reliable for the purpose of pruning while importing. |
5154 | 0 | bool activation_failure = false; |
5155 | 0 | for (auto c : GetAll()) { Branch (5155:33): [True: 0, False: 0]
|
5156 | 0 | BlockValidationState state; |
5157 | 0 | if (!c->ActivateBestChain(state, pblock)) { Branch (5157:29): [True: 0, False: 0]
|
5158 | 0 | LogPrint(BCLog::REINDEX, "failed to activate chain (%s)\n", state.ToString()); |
5159 | 0 | activation_failure = true; |
5160 | 0 | break; |
5161 | 0 | } |
5162 | 0 | } |
5163 | 0 | if (activation_failure) { Branch (5163:25): [True: 0, False: 0]
|
5164 | 0 | break; |
5165 | 0 | } |
5166 | 0 | } |
5167 | | |
5168 | 0 | NotifyHeaderTip(); |
5169 | |
|
5170 | 0 | if (!blocks_with_unknown_parent) continue; Branch (5170:21): [True: 0, False: 0]
|
5171 | | |
5172 | | // Recursively process earlier encountered successors of this block |
5173 | 0 | std::deque<uint256> queue; |
5174 | 0 | queue.push_back(hash); |
5175 | 0 | while (!queue.empty()) { Branch (5175:24): [True: 0, False: 0]
|
5176 | 0 | uint256 head = queue.front(); |
5177 | 0 | queue.pop_front(); |
5178 | 0 | auto range = blocks_with_unknown_parent->equal_range(head); |
5179 | 0 | while (range.first != range.second) { Branch (5179:28): [True: 0, False: 0]
|
5180 | 0 | std::multimap<uint256, FlatFilePos>::iterator it = range.first; |
5181 | 0 | std::shared_ptr<CBlock> pblockrecursive = std::make_shared<CBlock>(); |
5182 | 0 | if (m_blockman.ReadBlockFromDisk(*pblockrecursive, it->second)) { Branch (5182:29): [True: 0, False: 0]
|
5183 | 0 | LogPrint(BCLog::REINDEX, "%s: Processing out of order child %s of %s\n", __func__, pblockrecursive->GetHash().ToString(), |
5184 | 0 | head.ToString()); |
5185 | 0 | LOCK(cs_main); |
5186 | 0 | BlockValidationState dummy; |
5187 | 0 | if (AcceptBlock(pblockrecursive, dummy, nullptr, true, &it->second, nullptr, true)) { Branch (5187:33): [True: 0, False: 0]
|
5188 | 0 | nLoaded++; |
5189 | 0 | queue.push_back(pblockrecursive->GetHash()); |
5190 | 0 | } |
5191 | 0 | } |
5192 | 0 | range.first++; |
5193 | 0 | blocks_with_unknown_parent->erase(it); |
5194 | 0 | NotifyHeaderTip(); |
5195 | 0 | } |
5196 | 0 | } |
5197 | 0 | } catch (const std::exception& e) { |
5198 | | // historical bugs added extra data to the block files that does not deserialize cleanly. |
5199 | | // commonly this data is between readable blocks, but it does not really matter. such data is not fatal to the import process. |
5200 | | // the code that reads the block files deals with invalid data by simply ignoring it. |
5201 | | // it continues to search for the next {4 byte magic message start bytes + 4 byte length + block} that does deserialize cleanly |
5202 | | // and passes all of the other block validation checks dealing with POW and the merkle root, etc... |
5203 | | // we merely note with this informational log message when unexpected data is encountered. |
5204 | | // we could also be experiencing a storage system read error, or a read of a previous bad write. these are possible, but |
5205 | | // less likely scenarios. we don't have enough information to tell a difference here. |
5206 | | // the reindex process is not the place to attempt to clean and/or compact the block files. if so desired, a studious node operator |
5207 | | // may use knowledge of the fact that the block files are not entirely pristine in order to prepare a set of pristine, and |
5208 | | // perhaps ordered, block files for later reindexing. |
5209 | 0 | LogPrint(BCLog::REINDEX, "%s: unexpected data at file offset 0x%x - %s. continuing\n", __func__, (nRewind - 1), e.what()); |
5210 | 0 | } |
5211 | 0 | } |
5212 | 0 | } catch (const std::runtime_error& e) { |
5213 | 0 | GetNotifications().fatalError(strprintf(_("System error while loading external block file: %s"), e.what())); |
5214 | 0 | } |
5215 | 0 | LogPrintf("Loaded %i blocks from external file in %dms\n", nLoaded, Ticks<std::chrono::milliseconds>(SteadyClock::now() - start)); |
5216 | 0 | } |
5217 | | |
5218 | | bool ChainstateManager::ShouldCheckBlockIndex() const |
5219 | 6.84k | { |
5220 | | // Assert to verify Flatten() has been called. |
5221 | 6.84k | if (!*Assert(m_options.check_block_index)) return false; Branch (5221:9): [True: 0, False: 6.84k]
|
5222 | 6.84k | if (FastRandomContext().randrange(*m_options.check_block_index) >= 1) return false; Branch (5222:9): [True: 0, False: 6.84k]
|
5223 | 6.84k | return true; |
5224 | 6.84k | } |
5225 | | |
5226 | | void ChainstateManager::CheckBlockIndex() |
5227 | 6.84k | { |
5228 | 6.84k | if (!ShouldCheckBlockIndex()) { Branch (5228:9): [True: 0, False: 6.84k]
|
5229 | 0 | return; |
5230 | 0 | } |
5231 | | |
5232 | 6.84k | LOCK(cs_main); |
5233 | | |
5234 | | // During a reindex, we read the genesis block and call CheckBlockIndex before ActivateBestChain, |
5235 | | // so we have the genesis block in m_blockman.m_block_index but no active chain. (A few of the |
5236 | | // tests when iterating the block tree require that m_chain has been initialized.) |
5237 | 6.84k | if (ActiveChain().Height() < 0) { Branch (5237:9): [True: 0, False: 6.84k]
|
5238 | 0 | assert(m_blockman.m_block_index.size() <= 1); |
5239 | 0 | return; |
5240 | 0 | } |
5241 | | |
5242 | | // Build forward-pointing data structure for the entire block tree. |
5243 | | // For performance reasons, indexes of the best header chain are stored in a vector (within CChain). |
5244 | | // All remaining blocks are stored in a multimap. |
5245 | | // The best header chain can differ from the active chain: E.g. its entries may belong to blocks that |
5246 | | // are not yet validated. |
5247 | 6.84k | CChain best_hdr_chain; |
5248 | 6.84k | assert(m_best_header); |
5249 | 6.84k | best_hdr_chain.SetTip(*m_best_header); |
5250 | | |
5251 | 6.84k | std::multimap<CBlockIndex*,CBlockIndex*> forward; |
5252 | 6.84k | for (auto& [_, block_index] : m_blockman.m_block_index) { Branch (5252:33): [True: 6.84k, False: 6.84k]
|
5253 | | // Only save indexes in forward that are not part of the best header chain. |
5254 | 6.84k | if (!best_hdr_chain.Contains(&block_index)) { Branch (5254:13): [True: 0, False: 6.84k]
|
5255 | | // Only genesis, which must be part of the best header chain, can have a nullptr parent. |
5256 | 0 | assert(block_index.pprev); |
5257 | 0 | forward.emplace(block_index.pprev, &block_index); |
5258 | 0 | } |
5259 | 6.84k | } |
5260 | 6.84k | assert(forward.size() + best_hdr_chain.Height() + 1 == m_blockman.m_block_index.size()); |
5261 | | |
5262 | 6.84k | CBlockIndex* pindex = best_hdr_chain[0]; |
5263 | 6.84k | assert(pindex); |
5264 | | // Iterate over the entire block tree, using depth-first search. |
5265 | | // Along the way, remember whether there are blocks on the path from genesis |
5266 | | // block being explored which are the first to have certain properties. |
5267 | 6.84k | size_t nNodes = 0; |
5268 | 6.84k | int nHeight = 0; |
5269 | 6.84k | CBlockIndex* pindexFirstInvalid = nullptr; // Oldest ancestor of pindex which is invalid. |
5270 | 6.84k | CBlockIndex* pindexFirstMissing = nullptr; // Oldest ancestor of pindex which does not have BLOCK_HAVE_DATA, since assumeutxo snapshot if used. |
5271 | 6.84k | CBlockIndex* pindexFirstNeverProcessed = nullptr; // Oldest ancestor of pindex for which nTx == 0, since assumeutxo snapshot if used. |
5272 | 6.84k | CBlockIndex* pindexFirstNotTreeValid = nullptr; // Oldest ancestor of pindex which does not have BLOCK_VALID_TREE (regardless of being valid or not). |
5273 | 6.84k | CBlockIndex* pindexFirstNotTransactionsValid = nullptr; // Oldest ancestor of pindex which does not have BLOCK_VALID_TRANSACTIONS (regardless of being valid or not), since assumeutxo snapshot if used. |
5274 | 6.84k | CBlockIndex* pindexFirstNotChainValid = nullptr; // Oldest ancestor of pindex which does not have BLOCK_VALID_CHAIN (regardless of being valid or not), since assumeutxo snapshot if used. |
5275 | 6.84k | CBlockIndex* pindexFirstNotScriptsValid = nullptr; // Oldest ancestor of pindex which does not have BLOCK_VALID_SCRIPTS (regardless of being valid or not), since assumeutxo snapshot if used. |
5276 | | |
5277 | | // After checking an assumeutxo snapshot block, reset pindexFirst pointers |
5278 | | // to earlier blocks that have not been downloaded or validated yet, so |
5279 | | // checks for later blocks can assume the earlier blocks were validated and |
5280 | | // be stricter, testing for more requirements. |
5281 | 6.84k | const CBlockIndex* snap_base{GetSnapshotBaseBlock()}; |
5282 | 6.84k | CBlockIndex *snap_first_missing{}, *snap_first_notx{}, *snap_first_notv{}, *snap_first_nocv{}, *snap_first_nosv{}; |
5283 | 6.84k | auto snap_update_firsts = [&] { |
5284 | 6.84k | if (pindex == snap_base) { Branch (5284:13): [True: 0, False: 6.84k]
|
5285 | 0 | std::swap(snap_first_missing, pindexFirstMissing); |
5286 | 0 | std::swap(snap_first_notx, pindexFirstNeverProcessed); |
5287 | 0 | std::swap(snap_first_notv, pindexFirstNotTransactionsValid); |
5288 | 0 | std::swap(snap_first_nocv, pindexFirstNotChainValid); |
5289 | 0 | std::swap(snap_first_nosv, pindexFirstNotScriptsValid); |
5290 | 0 | } |
5291 | 6.84k | }; |
5292 | | |
5293 | 6.84k | while (pindex != nullptr) { Branch (5293:12): [True: 6.84k, False: 0]
|
5294 | 6.84k | nNodes++; |
5295 | 6.84k | if (pindexFirstInvalid == nullptr && pindex->nStatus & BLOCK_FAILED_VALID) pindexFirstInvalid = pindex; Branch (5295:13): [True: 6.84k, False: 0]
Branch (5295:46): [True: 0, False: 6.84k]
|
5296 | 6.84k | if (pindexFirstMissing == nullptr && !(pindex->nStatus & BLOCK_HAVE_DATA)) { Branch (5296:13): [True: 6.84k, False: 0]
Branch (5296:46): [True: 0, False: 6.84k]
|
5297 | 0 | pindexFirstMissing = pindex; |
5298 | 0 | } |
5299 | 6.84k | if (pindexFirstNeverProcessed == nullptr && pindex->nTx == 0) pindexFirstNeverProcessed = pindex; Branch (5299:13): [True: 6.84k, False: 0]
Branch (5299:53): [True: 0, False: 6.84k]
|
5300 | 6.84k | if (pindex->pprev != nullptr && pindexFirstNotTreeValid == nullptr && (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_TREE) pindexFirstNotTreeValid = pindex; Branch (5300:13): [True: 0, False: 6.84k]
Branch (5300:41): [True: 0, False: 0]
Branch (5300:79): [True: 0, False: 0]
|
5301 | | |
5302 | 6.84k | if (pindex->pprev != nullptr) { Branch (5302:13): [True: 0, False: 6.84k]
|
5303 | 0 | if (pindexFirstNotTransactionsValid == nullptr && Branch (5303:17): [True: 0, False: 0]
|
5304 | 0 | (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_TRANSACTIONS) { Branch (5304:21): [True: 0, False: 0]
|
5305 | 0 | pindexFirstNotTransactionsValid = pindex; |
5306 | 0 | } |
5307 | |
|
5308 | 0 | if (pindexFirstNotChainValid == nullptr && Branch (5308:17): [True: 0, False: 0]
|
5309 | 0 | (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_CHAIN) { Branch (5309:21): [True: 0, False: 0]
|
5310 | 0 | pindexFirstNotChainValid = pindex; |
5311 | 0 | } |
5312 | |
|
5313 | 0 | if (pindexFirstNotScriptsValid == nullptr && Branch (5313:17): [True: 0, False: 0]
|
5314 | 0 | (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_SCRIPTS) { Branch (5314:21): [True: 0, False: 0]
|
5315 | 0 | pindexFirstNotScriptsValid = pindex; |
5316 | 0 | } |
5317 | 0 | } |
5318 | | |
5319 | | // Begin: actual consistency checks. |
5320 | 6.84k | if (pindex->pprev == nullptr) { Branch (5320:13): [True: 6.84k, False: 0]
|
5321 | | // Genesis block checks. |
5322 | 6.84k | assert(pindex->GetBlockHash() == GetConsensus().hashGenesisBlock); // Genesis block's hash must match. |
5323 | 6.84k | for (auto c : GetAll()) { Branch (5323:25): [True: 6.84k, False: 6.84k]
|
5324 | 6.84k | if (c->m_chain.Genesis() != nullptr) { Branch (5324:21): [True: 6.84k, False: 0]
|
5325 | 6.84k | assert(pindex == c->m_chain.Genesis()); // The chain's genesis block must be this block. |
5326 | 6.84k | } |
5327 | 6.84k | } |
5328 | 6.84k | } |
5329 | 6.84k | if (!pindex->HaveNumChainTxs()) assert(pindex->nSequenceId <= 0); // nSequenceId can't be set positive for blocks that aren't linked (negative is used for preciousblock) Branch (5329:13): [True: 0, False: 6.84k]
|
5330 | | // VALID_TRANSACTIONS is equivalent to nTx > 0 for all nodes (whether or not pruning has occurred). |
5331 | | // HAVE_DATA is only equivalent to nTx > 0 (or VALID_TRANSACTIONS) if no pruning has occurred. |
5332 | 6.84k | if (!m_blockman.m_have_pruned) { Branch (5332:13): [True: 6.84k, False: 0]
|
5333 | | // If we've never pruned, then HAVE_DATA should be equivalent to nTx > 0 |
5334 | 6.84k | assert(!(pindex->nStatus & BLOCK_HAVE_DATA) == (pindex->nTx == 0)); |
5335 | 6.84k | assert(pindexFirstMissing == pindexFirstNeverProcessed); |
5336 | 6.84k | } else { |
5337 | | // If we have pruned, then we can only say that HAVE_DATA implies nTx > 0 |
5338 | 0 | if (pindex->nStatus & BLOCK_HAVE_DATA) assert(pindex->nTx > 0); Branch (5338:17): [True: 0, False: 0]
|
5339 | 0 | } |
5340 | 6.84k | if (pindex->nStatus & BLOCK_HAVE_UNDO) assert(pindex->nStatus & BLOCK_HAVE_DATA); Branch (5340:13): [True: 0, False: 6.84k]
|
5341 | 6.84k | if (snap_base && snap_base->GetAncestor(pindex->nHeight) == pindex) { Branch (5341:13): [True: 0, False: 6.84k]
Branch (5341:26): [True: 0, False: 0]
|
5342 | | // Assumed-valid blocks should connect to the main chain. |
5343 | 0 | assert((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_TREE); |
5344 | 0 | } |
5345 | | // There should only be an nTx value if we have |
5346 | | // actually seen a block's transactions. |
5347 | 6.84k | assert(((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_TRANSACTIONS) == (pindex->nTx > 0)); // This is pruning-independent. |
5348 | | // All parents having had data (at some point) is equivalent to all parents being VALID_TRANSACTIONS, which is equivalent to HaveNumChainTxs(). |
5349 | | // HaveNumChainTxs will also be set in the assumeutxo snapshot block from snapshot metadata. |
5350 | 6.84k | assert((pindexFirstNeverProcessed == nullptr || pindex == snap_base) == pindex->HaveNumChainTxs()); |
5351 | 6.84k | assert((pindexFirstNotTransactionsValid == nullptr || pindex == snap_base) == pindex->HaveNumChainTxs()); |
5352 | 6.84k | assert(pindex->nHeight == nHeight); // nHeight must be consistent. |
5353 | 6.84k | 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. |
5354 | 6.84k | assert(nHeight < 2 || (pindex->pskip && (pindex->pskip->nHeight < nHeight))); // The pskip pointer must point back for all but the first 2 blocks. |
5355 | 6.84k | assert(pindexFirstNotTreeValid == nullptr); // All m_blockman.m_block_index entries must at least be TREE valid |
5356 | 6.84k | if ((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_TREE) assert(pindexFirstNotTreeValid == nullptr); // TREE valid implies all parents are TREE valid Branch (5356:13): [True: 6.84k, False: 0]
|
5357 | 6.84k | if ((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_CHAIN) assert(pindexFirstNotChainValid == nullptr); // CHAIN valid implies all parents are CHAIN valid Branch (5357:13): [True: 0, False: 6.84k]
|
5358 | 6.84k | if ((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_SCRIPTS) assert(pindexFirstNotScriptsValid == nullptr); // SCRIPTS valid implies all parents are SCRIPTS valid Branch (5358:13): [True: 0, False: 6.84k]
|
5359 | 6.84k | if (pindexFirstInvalid == nullptr) { Branch (5359:13): [True: 6.84k, False: 0]
|
5360 | | // Checks for not-invalid blocks. |
5361 | 6.84k | assert((pindex->nStatus & BLOCK_FAILED_MASK) == 0); // The failed mask cannot be set for blocks without invalid parents. |
5362 | 6.84k | } |
5363 | | // Make sure m_chain_tx_count sum is correctly computed. |
5364 | 6.84k | if (!pindex->pprev) { Branch (5364:13): [True: 6.84k, False: 0]
|
5365 | | // If no previous block, nTx and m_chain_tx_count must be the same. |
5366 | 6.84k | assert(pindex->m_chain_tx_count == pindex->nTx); |
5367 | 6.84k | } else if (pindex->pprev->m_chain_tx_count > 0 && pindex->nTx > 0) { Branch (5367:20): [True: 0, False: 0]
Branch (5367:59): [True: 0, False: 0]
|
5368 | | // If previous m_chain_tx_count is set and number of transactions in block is known, sum must be set. |
5369 | 0 | assert(pindex->m_chain_tx_count == pindex->nTx + pindex->pprev->m_chain_tx_count); |
5370 | 0 | } else { |
5371 | | // Otherwise m_chain_tx_count should only be set if this is a snapshot |
5372 | | // block, and must be set if it is. |
5373 | 0 | assert((pindex->m_chain_tx_count != 0) == (pindex == snap_base)); |
5374 | 0 | } |
5375 | | |
5376 | | // Chainstate-specific checks on setBlockIndexCandidates |
5377 | 6.84k | for (auto c : GetAll()) { Branch (5377:21): [True: 6.84k, False: 6.84k]
|
5378 | 6.84k | if (c->m_chain.Tip() == nullptr) continue; Branch (5378:17): [True: 0, False: 6.84k]
|
5379 | | // Two main factors determine whether pindex is a candidate in |
5380 | | // setBlockIndexCandidates: |
5381 | | // |
5382 | | // - If pindex has less work than the chain tip, it should not be a |
5383 | | // candidate, and this will be asserted below. Otherwise it is a |
5384 | | // potential candidate. |
5385 | | // |
5386 | | // - If pindex or one of its parent blocks back to the genesis block |
5387 | | // or an assumeutxo snapshot never downloaded transactions |
5388 | | // (pindexFirstNeverProcessed is non-null), it should not be a |
5389 | | // candidate, and this will be asserted below. The only exception |
5390 | | // is if pindex itself is an assumeutxo snapshot block. Then it is |
5391 | | // also a potential candidate. |
5392 | 6.84k | if (!CBlockIndexWorkComparator()(pindex, c->m_chain.Tip()) && (pindexFirstNeverProcessed == nullptr || pindex == snap_base)) { Branch (5392:17): [True: 6.84k, False: 0]
Branch (5392:17): [True: 6.84k, False: 0]
Branch (5392:76): [True: 6.84k, False: 0]
Branch (5392:116): [True: 0, False: 0]
|
5393 | | // If pindex was detected as invalid (pindexFirstInvalid is |
5394 | | // non-null), it is not required to be in |
5395 | | // setBlockIndexCandidates. |
5396 | 6.84k | if (pindexFirstInvalid == nullptr) { Branch (5396:21): [True: 6.84k, False: 0]
|
5397 | | // If pindex and all its parents back to the genesis block |
5398 | | // or an assumeutxo snapshot block downloaded transactions, |
5399 | | // and the transactions were not pruned (pindexFirstMissing |
5400 | | // is null), it is a potential candidate. The check |
5401 | | // excludes pruned blocks, because if any blocks were |
5402 | | // pruned between pindex and the current chain tip, pindex will |
5403 | | // only temporarily be added to setBlockIndexCandidates, |
5404 | | // before being moved to m_blocks_unlinked. This check |
5405 | | // could be improved to verify that if all blocks between |
5406 | | // the chain tip and pindex have data, pindex must be a |
5407 | | // candidate. |
5408 | | // |
5409 | | // If pindex is the chain tip, it also is a potential |
5410 | | // candidate. |
5411 | | // |
5412 | | // If the chainstate was loaded from a snapshot and pindex |
5413 | | // is the base of the snapshot, pindex is also a potential |
5414 | | // candidate. |
5415 | 6.84k | if (pindexFirstMissing == nullptr || pindex == c->m_chain.Tip() || pindex == c->SnapshotBase()) { Branch (5415:25): [True: 6.84k, False: 0]
Branch (5415:58): [True: 0, False: 0]
Branch (5415:88): [True: 0, False: 0]
|
5416 | | // If this chainstate is the active chainstate, pindex |
5417 | | // must be in setBlockIndexCandidates. Otherwise, this |
5418 | | // chainstate is a background validation chainstate, and |
5419 | | // pindex only needs to be added if it is an ancestor of |
5420 | | // the snapshot that is being validated. |
5421 | 6.84k | if (c == &ActiveChainstate() || snap_base->GetAncestor(pindex->nHeight) == pindex) { Branch (5421:29): [True: 6.84k, False: 0]
Branch (5421:57): [True: 0, False: 0]
|
5422 | 6.84k | assert(c->setBlockIndexCandidates.count(pindex)); |
5423 | 6.84k | } |
5424 | 6.84k | } |
5425 | | // If some parent is missing, then it could be that this block was in |
5426 | | // setBlockIndexCandidates but had to be removed because of the missing data. |
5427 | | // In this case it must be in m_blocks_unlinked -- see test below. |
5428 | 6.84k | } |
5429 | 6.84k | } else { // If this block sorts worse than the current tip or some ancestor's block has never been seen, it cannot be in setBlockIndexCandidates. |
5430 | 0 | assert(c->setBlockIndexCandidates.count(pindex) == 0); |
5431 | 0 | } |
5432 | 6.84k | } |
5433 | | // Check whether this block is in m_blocks_unlinked. |
5434 | 6.84k | std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> rangeUnlinked = m_blockman.m_blocks_unlinked.equal_range(pindex->pprev); |
5435 | 6.84k | bool foundInUnlinked = false; |
5436 | 6.84k | while (rangeUnlinked.first != rangeUnlinked.second) { Branch (5436:16): [True: 0, False: 6.84k]
|
5437 | 0 | assert(rangeUnlinked.first->first == pindex->pprev); |
5438 | 0 | if (rangeUnlinked.first->second == pindex) { Branch (5438:17): [True: 0, False: 0]
|
5439 | 0 | foundInUnlinked = true; |
5440 | 0 | break; |
5441 | 0 | } |
5442 | 0 | rangeUnlinked.first++; |
5443 | 0 | } |
5444 | 6.84k | if (pindex->pprev && (pindex->nStatus & BLOCK_HAVE_DATA) && pindexFirstNeverProcessed != nullptr && pindexFirstInvalid == nullptr) { Branch (5444:13): [True: 0, False: 6.84k]
Branch (5444:30): [True: 0, False: 0]
Branch (5444:69): [True: 0, False: 0]
Branch (5444:109): [True: 0, False: 0]
|
5445 | | // If this block has block data available, some parent was never received, and has no invalid parents, it must be in m_blocks_unlinked. |
5446 | 0 | assert(foundInUnlinked); |
5447 | 0 | } |
5448 | 6.84k | if (!(pindex->nStatus & BLOCK_HAVE_DATA)) assert(!foundInUnlinked); // Can't be in m_blocks_unlinked if we don't HAVE_DATA Branch (5448:13): [True: 0, False: 6.84k]
|
5449 | 6.84k | if (pindexFirstMissing == nullptr) assert(!foundInUnlinked); // We aren't missing data for any parent -- cannot be in m_blocks_unlinked. Branch (5449:13): [True: 6.84k, False: 0]
|
5450 | 6.84k | if (pindex->pprev && (pindex->nStatus & BLOCK_HAVE_DATA) && pindexFirstNeverProcessed == nullptr && pindexFirstMissing != nullptr) { Branch (5450:13): [True: 0, False: 6.84k]
Branch (5450:30): [True: 0, False: 0]
Branch (5450:69): [True: 0, False: 0]
Branch (5450:109): [True: 0, False: 0]
|
5451 | | // We HAVE_DATA for this block, have received data for all parents at some point, but we're currently missing data for some parent. |
5452 | 0 | assert(m_blockman.m_have_pruned); |
5453 | | // This block may have entered m_blocks_unlinked if: |
5454 | | // - it has a descendant that at some point had more work than the |
5455 | | // tip, and |
5456 | | // - we tried switching to that descendant but were missing |
5457 | | // data for some intermediate block between m_chain and the |
5458 | | // tip. |
5459 | | // So if this block is itself better than any m_chain.Tip() and it wasn't in |
5460 | | // setBlockIndexCandidates, then it must be in m_blocks_unlinked. |
5461 | 0 | for (auto c : GetAll()) { Branch (5461:25): [True: 0, False: 0]
|
5462 | 0 | const bool is_active = c == &ActiveChainstate(); |
5463 | 0 | if (!CBlockIndexWorkComparator()(pindex, c->m_chain.Tip()) && c->setBlockIndexCandidates.count(pindex) == 0) { Branch (5463:21): [True: 0, False: 0]
Branch (5463:21): [True: 0, False: 0]
Branch (5463:79): [True: 0, False: 0]
|
5464 | 0 | if (pindexFirstInvalid == nullptr) { Branch (5464:25): [True: 0, False: 0]
|
5465 | 0 | if (is_active || snap_base->GetAncestor(pindex->nHeight) == pindex) { Branch (5465:29): [True: 0, False: 0]
Branch (5465:42): [True: 0, False: 0]
|
5466 | 0 | assert(foundInUnlinked); |
5467 | 0 | } |
5468 | 0 | } |
5469 | 0 | } |
5470 | 0 | } |
5471 | 0 | } |
5472 | | // assert(pindex->GetBlockHash() == pindex->GetBlockHeader().GetHash()); // Perhaps too slow |
5473 | | // End: actual consistency checks. |
5474 | | |
5475 | | |
5476 | | // Try descending into the first subnode. Always process forks first and the best header chain after. |
5477 | 6.84k | snap_update_firsts(); |
5478 | 6.84k | std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> range = forward.equal_range(pindex); |
5479 | 6.84k | if (range.first != range.second) { Branch (5479:13): [True: 0, False: 6.84k]
|
5480 | | // A subnode not part of the best header chain was found. |
5481 | 0 | pindex = range.first->second; |
5482 | 0 | nHeight++; |
5483 | 0 | continue; |
5484 | 6.84k | } else if (best_hdr_chain.Contains(pindex)) { Branch (5484:20): [True: 6.84k, False: 0]
|
5485 | | // Descend further into best header chain. |
5486 | 6.84k | nHeight++; |
5487 | 6.84k | pindex = best_hdr_chain[nHeight]; |
5488 | 6.84k | if (!pindex) break; // we are finished, since the best header chain is always processed last Branch (5488:17): [True: 6.84k, False: 0]
|
5489 | 0 | continue; |
5490 | 6.84k | } |
5491 | | // This is a leaf node. |
5492 | | // Move upwards until we reach a node of which we have not yet visited the last child. |
5493 | 0 | while (pindex) { Branch (5493:16): [True: 0, False: 0]
|
5494 | | // We are going to either move to a parent or a sibling of pindex. |
5495 | 0 | snap_update_firsts(); |
5496 | | // If pindex was the first with a certain property, unset the corresponding variable. |
5497 | 0 | if (pindex == pindexFirstInvalid) pindexFirstInvalid = nullptr; Branch (5497:17): [True: 0, False: 0]
|
5498 | 0 | if (pindex == pindexFirstMissing) pindexFirstMissing = nullptr; Branch (5498:17): [True: 0, False: 0]
|
5499 | 0 | if (pindex == pindexFirstNeverProcessed) pindexFirstNeverProcessed = nullptr; Branch (5499:17): [True: 0, False: 0]
|
5500 | 0 | if (pindex == pindexFirstNotTreeValid) pindexFirstNotTreeValid = nullptr; Branch (5500:17): [True: 0, False: 0]
|
5501 | 0 | if (pindex == pindexFirstNotTransactionsValid) pindexFirstNotTransactionsValid = nullptr; Branch (5501:17): [True: 0, False: 0]
|
5502 | 0 | if (pindex == pindexFirstNotChainValid) pindexFirstNotChainValid = nullptr; Branch (5502:17): [True: 0, False: 0]
|
5503 | 0 | if (pindex == pindexFirstNotScriptsValid) pindexFirstNotScriptsValid = nullptr; Branch (5503:17): [True: 0, False: 0]
|
5504 | | // Find our parent. |
5505 | 0 | CBlockIndex* pindexPar = pindex->pprev; |
5506 | | // Find which child we just visited. |
5507 | 0 | std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> rangePar = forward.equal_range(pindexPar); |
5508 | 0 | while (rangePar.first->second != pindex) { Branch (5508:20): [True: 0, False: 0]
|
5509 | 0 | assert(rangePar.first != rangePar.second); // Our parent must have at least the node we're coming from as child. |
5510 | 0 | rangePar.first++; |
5511 | 0 | } |
5512 | | // Proceed to the next one. |
5513 | 0 | rangePar.first++; |
5514 | 0 | if (rangePar.first != rangePar.second) { Branch (5514:17): [True: 0, False: 0]
|
5515 | | // Move to a sibling not part of the best header chain. |
5516 | 0 | pindex = rangePar.first->second; |
5517 | 0 | break; |
5518 | 0 | } else if (pindexPar == best_hdr_chain[nHeight - 1]) { Branch (5518:24): [True: 0, False: 0]
|
5519 | | // Move to pindex's sibling on the best-chain, if it has one. |
5520 | 0 | pindex = best_hdr_chain[nHeight]; |
5521 | | // There will not be a next block if (and only if) parent block is the best header. |
5522 | 0 | assert((pindex == nullptr) == (pindexPar == best_hdr_chain.Tip())); |
5523 | 0 | break; |
5524 | 0 | } else { |
5525 | | // Move up further. |
5526 | 0 | pindex = pindexPar; |
5527 | 0 | nHeight--; |
5528 | 0 | continue; |
5529 | 0 | } |
5530 | 0 | } |
5531 | 0 | } |
5532 | | |
5533 | | // Check that we actually traversed the entire block index. |
5534 | 6.84k | assert(nNodes == forward.size() + best_hdr_chain.Height() + 1); |
5535 | 6.84k | } |
5536 | | |
5537 | | std::string Chainstate::ToString() |
5538 | 0 | { |
5539 | 0 | AssertLockHeld(::cs_main); |
5540 | 0 | CBlockIndex* tip = m_chain.Tip(); |
5541 | 0 | return strprintf("Chainstate [%s] @ height %d (%s)", |
5542 | 0 | m_from_snapshot_blockhash ? "snapshot" : "ibd", Branch (5542:22): [True: 0, False: 0]
|
5543 | 0 | tip ? tip->nHeight : -1, tip ? tip->GetBlockHash().ToString() : "null"); Branch (5543:22): [True: 0, False: 0]
Branch (5543:47): [True: 0, False: 0]
|
5544 | 0 | } |
5545 | | |
5546 | | bool Chainstate::ResizeCoinsCaches(size_t coinstip_size, size_t coinsdb_size) |
5547 | 0 | { |
5548 | 0 | AssertLockHeld(::cs_main); |
5549 | 0 | if (coinstip_size == m_coinstip_cache_size_bytes && Branch (5549:9): [True: 0, False: 0]
|
5550 | 0 | coinsdb_size == m_coinsdb_cache_size_bytes) { Branch (5550:13): [True: 0, False: 0]
|
5551 | | // Cache sizes are unchanged, no need to continue. |
5552 | 0 | return true; |
5553 | 0 | } |
5554 | 0 | size_t old_coinstip_size = m_coinstip_cache_size_bytes; |
5555 | 0 | m_coinstip_cache_size_bytes = coinstip_size; |
5556 | 0 | m_coinsdb_cache_size_bytes = coinsdb_size; |
5557 | 0 | CoinsDB().ResizeCache(coinsdb_size); |
5558 | |
|
5559 | 0 | LogPrintf("[%s] resized coinsdb cache to %.1f MiB\n", |
5560 | 0 | this->ToString(), coinsdb_size * (1.0 / 1024 / 1024)); |
5561 | 0 | LogPrintf("[%s] resized coinstip cache to %.1f MiB\n", |
5562 | 0 | this->ToString(), coinstip_size * (1.0 / 1024 / 1024)); |
5563 | |
|
5564 | 0 | BlockValidationState state; |
5565 | 0 | bool ret; |
5566 | |
|
5567 | 0 | if (coinstip_size > old_coinstip_size) { Branch (5567:9): [True: 0, False: 0]
|
5568 | | // Likely no need to flush if cache sizes have grown. |
5569 | 0 | ret = FlushStateToDisk(state, FlushStateMode::IF_NEEDED); |
5570 | 0 | } else { |
5571 | | // Otherwise, flush state to disk and deallocate the in-memory coins map. |
5572 | 0 | ret = FlushStateToDisk(state, FlushStateMode::ALWAYS); |
5573 | 0 | } |
5574 | 0 | return ret; |
5575 | 0 | } |
5576 | | |
5577 | | //! Guess how far we are in the verification process at the given block index |
5578 | | //! require cs_main if pindex has not been validated yet (because m_chain_tx_count might be unset) |
5579 | 0 | double GuessVerificationProgress(const ChainTxData& data, const CBlockIndex *pindex) { |
5580 | 0 | if (pindex == nullptr) Branch (5580:9): [True: 0, False: 0]
|
5581 | 0 | return 0.0; |
5582 | | |
5583 | 0 | if (!Assume(pindex->m_chain_tx_count > 0)) { Branch (5583:9): [True: 0, False: 0]
|
5584 | 0 | LogWarning("Internal bug detected: block %d has unset m_chain_tx_count (%s %s). Please report this issue here: %s\n", |
5585 | 0 | pindex->nHeight, PACKAGE_NAME, FormatFullVersion(), PACKAGE_BUGREPORT); |
5586 | 0 | return 0.0; |
5587 | 0 | } |
5588 | | |
5589 | 0 | int64_t nNow = time(nullptr); |
5590 | |
|
5591 | 0 | double fTxTotal; |
5592 | |
|
5593 | 0 | if (pindex->m_chain_tx_count <= data.tx_count) { Branch (5593:9): [True: 0, False: 0]
|
5594 | 0 | fTxTotal = data.tx_count + (nNow - data.nTime) * data.dTxRate; |
5595 | 0 | } else { |
5596 | 0 | fTxTotal = pindex->m_chain_tx_count + (nNow - pindex->GetBlockTime()) * data.dTxRate; |
5597 | 0 | } |
5598 | |
|
5599 | 0 | return std::min<double>(pindex->m_chain_tx_count / fTxTotal, 1.0); |
5600 | 0 | } |
5601 | | |
5602 | | std::optional<uint256> ChainstateManager::SnapshotBlockhash() const |
5603 | 0 | { |
5604 | 0 | LOCK(::cs_main); |
5605 | 0 | if (m_active_chainstate && m_active_chainstate->m_from_snapshot_blockhash) { Branch (5605:9): [True: 0, False: 0]
Branch (5605:32): [True: 0, False: 0]
|
5606 | | // If a snapshot chainstate exists, it will always be our active. |
5607 | 0 | return m_active_chainstate->m_from_snapshot_blockhash; |
5608 | 0 | } |
5609 | 0 | return std::nullopt; |
5610 | 0 | } |
5611 | | |
5612 | | std::vector<Chainstate*> ChainstateManager::GetAll() |
5613 | 13.6k | { |
5614 | 13.6k | LOCK(::cs_main); |
5615 | 13.6k | std::vector<Chainstate*> out; |
5616 | | |
5617 | 27.3k | for (Chainstate* cs : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) { Branch (5617:25): [True: 27.3k, False: 13.6k]
|
5618 | 27.3k | if (this->IsUsable(cs)) out.push_back(cs); Branch (5618:13): [True: 13.6k, False: 13.6k]
|
5619 | 27.3k | } |
5620 | | |
5621 | 13.6k | return out; |
5622 | 13.6k | } |
5623 | | |
5624 | | Chainstate& ChainstateManager::InitializeChainstate(CTxMemPool* mempool) |
5625 | 0 | { |
5626 | 0 | AssertLockHeld(::cs_main); |
5627 | 0 | assert(!m_ibd_chainstate); |
5628 | 0 | assert(!m_active_chainstate); |
5629 | | |
5630 | 0 | m_ibd_chainstate = std::make_unique<Chainstate>(mempool, m_blockman, *this); |
5631 | 0 | m_active_chainstate = m_ibd_chainstate.get(); |
5632 | 0 | return *m_active_chainstate; |
5633 | 0 | } |
5634 | | |
5635 | | [[nodiscard]] static bool DeleteCoinsDBFromDisk(const fs::path db_path, bool is_snapshot) |
5636 | | EXCLUSIVE_LOCKS_REQUIRED(::cs_main) |
5637 | 0 | { |
5638 | 0 | AssertLockHeld(::cs_main); |
5639 | |
|
5640 | 0 | if (is_snapshot) { Branch (5640:9): [True: 0, False: 0]
|
5641 | 0 | fs::path base_blockhash_path = db_path / node::SNAPSHOT_BLOCKHASH_FILENAME; |
5642 | |
|
5643 | 0 | try { |
5644 | 0 | bool existed = fs::remove(base_blockhash_path); |
5645 | 0 | if (!existed) { Branch (5645:17): [True: 0, False: 0]
|
5646 | 0 | LogPrintf("[snapshot] snapshot chainstate dir being removed lacks %s file\n", |
5647 | 0 | fs::PathToString(node::SNAPSHOT_BLOCKHASH_FILENAME)); |
5648 | 0 | } |
5649 | 0 | } catch (const fs::filesystem_error& e) { |
5650 | 0 | LogPrintf("[snapshot] failed to remove file %s: %s\n", |
5651 | 0 | fs::PathToString(base_blockhash_path), fsbridge::get_filesystem_error_message(e)); |
5652 | 0 | } |
5653 | 0 | } |
5654 | |
|
5655 | 0 | std::string path_str = fs::PathToString(db_path); |
5656 | 0 | LogPrintf("Removing leveldb dir at %s\n", path_str); |
5657 | | |
5658 | | // We have to destruct before this call leveldb::DB in order to release the db |
5659 | | // lock, otherwise `DestroyDB` will fail. See `leveldb::~DBImpl()`. |
5660 | 0 | const bool destroyed = DestroyDB(path_str); |
5661 | |
|
5662 | 0 | if (!destroyed) { Branch (5662:9): [True: 0, False: 0]
|
5663 | 0 | LogPrintf("error: leveldb DestroyDB call failed on %s\n", path_str); |
5664 | 0 | } |
5665 | | |
5666 | | // Datadir should be removed from filesystem; otherwise initialization may detect |
5667 | | // it on subsequent statups and get confused. |
5668 | | // |
5669 | | // If the base_blockhash_path removal above fails in the case of snapshot |
5670 | | // chainstates, this will return false since leveldb won't remove a non-empty |
5671 | | // directory. |
5672 | 0 | return destroyed && !fs::exists(db_path); Branch (5672:12): [True: 0, False: 0]
Branch (5672:25): [True: 0, False: 0]
|
5673 | 0 | } |
5674 | | |
5675 | | util::Result<CBlockIndex*> ChainstateManager::ActivateSnapshot( |
5676 | | AutoFile& coins_file, |
5677 | | const SnapshotMetadata& metadata, |
5678 | | bool in_memory) |
5679 | 0 | { |
5680 | 0 | uint256 base_blockhash = metadata.m_base_blockhash; |
5681 | |
|
5682 | 0 | if (this->SnapshotBlockhash()) { Branch (5682:9): [True: 0, False: 0]
|
5683 | 0 | return util::Error{Untranslated("Can't activate a snapshot-based chainstate more than once")}; |
5684 | 0 | } |
5685 | | |
5686 | 0 | CBlockIndex* snapshot_start_block{}; |
5687 | |
|
5688 | 0 | { |
5689 | 0 | LOCK(::cs_main); |
5690 | |
|
5691 | 0 | if (!GetParams().AssumeutxoForBlockhash(base_blockhash).has_value()) { Branch (5691:13): [True: 0, False: 0]
|
5692 | 0 | auto available_heights = GetParams().GetAvailableSnapshotHeights(); |
5693 | 0 | std::string heights_formatted = util::Join(available_heights, ", ", [&](const auto& i) { return util::ToString(i); }); |
5694 | 0 | return util::Error{strprintf(Untranslated("assumeutxo block hash in snapshot metadata not recognized (hash: %s). The following snapshot heights are available: %s"), |
5695 | 0 | base_blockhash.ToString(), |
5696 | 0 | heights_formatted)}; |
5697 | 0 | } |
5698 | | |
5699 | 0 | snapshot_start_block = m_blockman.LookupBlockIndex(base_blockhash); |
5700 | 0 | if (!snapshot_start_block) { Branch (5700:13): [True: 0, False: 0]
|
5701 | 0 | return util::Error{strprintf(Untranslated("The base block header (%s) must appear in the headers chain. Make sure all headers are syncing, and call loadtxoutset again"), |
5702 | 0 | base_blockhash.ToString())}; |
5703 | 0 | } |
5704 | | |
5705 | 0 | bool start_block_invalid = snapshot_start_block->nStatus & BLOCK_FAILED_MASK; |
5706 | 0 | if (start_block_invalid) { Branch (5706:13): [True: 0, False: 0]
|
5707 | 0 | return util::Error{strprintf(Untranslated("The base block header (%s) is part of an invalid chain"), base_blockhash.ToString())}; |
5708 | 0 | } |
5709 | | |
5710 | 0 | if (!m_best_header || m_best_header->GetAncestor(snapshot_start_block->nHeight) != snapshot_start_block) { Branch (5710:13): [True: 0, False: 0]
Branch (5710:31): [True: 0, False: 0]
|
5711 | 0 | return util::Error{Untranslated("A forked headers-chain with more work than the chain with the snapshot base block header exists. Please proceed to sync without AssumeUtxo.")}; |
5712 | 0 | } |
5713 | | |
5714 | 0 | auto mempool{m_active_chainstate->GetMempool()}; |
5715 | 0 | if (mempool && mempool->size() > 0) { Branch (5715:13): [True: 0, False: 0]
Branch (5715:24): [True: 0, False: 0]
|
5716 | 0 | return util::Error{Untranslated("Can't activate a snapshot when mempool not empty")}; |
5717 | 0 | } |
5718 | 0 | } |
5719 | | |
5720 | 0 | int64_t current_coinsdb_cache_size{0}; |
5721 | 0 | int64_t current_coinstip_cache_size{0}; |
5722 | | |
5723 | | // Cache percentages to allocate to each chainstate. |
5724 | | // |
5725 | | // These particular percentages don't matter so much since they will only be |
5726 | | // relevant during snapshot activation; caches are rebalanced at the conclusion of |
5727 | | // this function. We want to give (essentially) all available cache capacity to the |
5728 | | // snapshot to aid the bulk load later in this function. |
5729 | 0 | static constexpr double IBD_CACHE_PERC = 0.01; |
5730 | 0 | static constexpr double SNAPSHOT_CACHE_PERC = 0.99; |
5731 | |
|
5732 | 0 | { |
5733 | 0 | LOCK(::cs_main); |
5734 | | // Resize the coins caches to ensure we're not exceeding memory limits. |
5735 | | // |
5736 | | // Allocate the majority of the cache to the incoming snapshot chainstate, since |
5737 | | // (optimistically) getting to its tip will be the top priority. We'll need to call |
5738 | | // `MaybeRebalanceCaches()` once we're done with this function to ensure |
5739 | | // the right allocation (including the possibility that no snapshot was activated |
5740 | | // and that we should restore the active chainstate caches to their original size). |
5741 | | // |
5742 | 0 | current_coinsdb_cache_size = this->ActiveChainstate().m_coinsdb_cache_size_bytes; |
5743 | 0 | current_coinstip_cache_size = this->ActiveChainstate().m_coinstip_cache_size_bytes; |
5744 | | |
5745 | | // Temporarily resize the active coins cache to make room for the newly-created |
5746 | | // snapshot chain. |
5747 | 0 | this->ActiveChainstate().ResizeCoinsCaches( |
5748 | 0 | static_cast<size_t>(current_coinstip_cache_size * IBD_CACHE_PERC), |
5749 | 0 | static_cast<size_t>(current_coinsdb_cache_size * IBD_CACHE_PERC)); |
5750 | 0 | } |
5751 | |
|
5752 | 0 | auto snapshot_chainstate = WITH_LOCK(::cs_main, |
5753 | 0 | return std::make_unique<Chainstate>( |
5754 | 0 | /*mempool=*/nullptr, m_blockman, *this, base_blockhash)); |
5755 | |
|
5756 | 0 | { |
5757 | 0 | LOCK(::cs_main); |
5758 | 0 | snapshot_chainstate->InitCoinsDB( |
5759 | 0 | static_cast<size_t>(current_coinsdb_cache_size * SNAPSHOT_CACHE_PERC), |
5760 | 0 | in_memory, false, "chainstate"); |
5761 | 0 | snapshot_chainstate->InitCoinsCache( |
5762 | 0 | static_cast<size_t>(current_coinstip_cache_size * SNAPSHOT_CACHE_PERC)); |
5763 | 0 | } |
5764 | |
|
5765 | 0 | auto cleanup_bad_snapshot = [&](bilingual_str reason) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) { |
5766 | 0 | this->MaybeRebalanceCaches(); |
5767 | | |
5768 | | // PopulateAndValidateSnapshot can return (in error) before the leveldb datadir |
5769 | | // has been created, so only attempt removal if we got that far. |
5770 | 0 | if (auto snapshot_datadir = node::FindSnapshotChainstateDir(m_options.datadir)) { Branch (5770:18): [True: 0, False: 0]
|
5771 | | // We have to destruct leveldb::DB in order to release the db lock, otherwise |
5772 | | // DestroyDB() (in DeleteCoinsDBFromDisk()) will fail. See `leveldb::~DBImpl()`. |
5773 | | // Destructing the chainstate (and so resetting the coinsviews object) does this. |
5774 | 0 | snapshot_chainstate.reset(); |
5775 | 0 | bool removed = DeleteCoinsDBFromDisk(*snapshot_datadir, /*is_snapshot=*/true); |
5776 | 0 | if (!removed) { Branch (5776:17): [True: 0, False: 0]
|
5777 | 0 | GetNotifications().fatalError(strprintf(_("Failed to remove snapshot chainstate dir (%s). " |
5778 | 0 | "Manually remove it before restarting.\n"), fs::PathToString(*snapshot_datadir))); |
5779 | 0 | } |
5780 | 0 | } |
5781 | 0 | return util::Error{std::move(reason)}; |
5782 | 0 | }; |
5783 | |
|
5784 | 0 | if (auto res{this->PopulateAndValidateSnapshot(*snapshot_chainstate, coins_file, metadata)}; !res) { Branch (5784:98): [True: 0, False: 0]
|
5785 | 0 | LOCK(::cs_main); |
5786 | 0 | return cleanup_bad_snapshot(strprintf(Untranslated("Population failed: %s"), util::ErrorString(res))); |
5787 | 0 | } |
5788 | | |
5789 | 0 | LOCK(::cs_main); // cs_main required for rest of snapshot activation. |
5790 | | |
5791 | | // Do a final check to ensure that the snapshot chainstate is actually a more |
5792 | | // work chain than the active chainstate; a user could have loaded a snapshot |
5793 | | // very late in the IBD process, and we wouldn't want to load a useless chainstate. |
5794 | 0 | if (!CBlockIndexWorkComparator()(ActiveTip(), snapshot_chainstate->m_chain.Tip())) { Branch (5794:9): [True: 0, False: 0]
|
5795 | 0 | return cleanup_bad_snapshot(Untranslated("work does not exceed active chainstate")); |
5796 | 0 | } |
5797 | | // If not in-memory, persist the base blockhash for use during subsequent |
5798 | | // initialization. |
5799 | 0 | if (!in_memory) { Branch (5799:9): [True: 0, False: 0]
|
5800 | 0 | if (!node::WriteSnapshotBaseBlockhash(*snapshot_chainstate)) { Branch (5800:13): [True: 0, False: 0]
|
5801 | 0 | return cleanup_bad_snapshot(Untranslated("could not write base blockhash")); |
5802 | 0 | } |
5803 | 0 | } |
5804 | | |
5805 | 0 | assert(!m_snapshot_chainstate); |
5806 | 0 | m_snapshot_chainstate.swap(snapshot_chainstate); |
5807 | 0 | const bool chaintip_loaded = m_snapshot_chainstate->LoadChainTip(); |
5808 | 0 | assert(chaintip_loaded); |
5809 | | |
5810 | | // Transfer possession of the mempool to the snapshot chainstate. |
5811 | | // Mempool is empty at this point because we're still in IBD. |
5812 | 0 | Assert(m_active_chainstate->m_mempool->size() == 0); |
5813 | 0 | Assert(!m_snapshot_chainstate->m_mempool); |
5814 | 0 | m_snapshot_chainstate->m_mempool = m_active_chainstate->m_mempool; |
5815 | 0 | m_active_chainstate->m_mempool = nullptr; |
5816 | 0 | m_active_chainstate = m_snapshot_chainstate.get(); |
5817 | 0 | m_blockman.m_snapshot_height = this->GetSnapshotBaseHeight(); |
5818 | |
|
5819 | 0 | LogPrintf("[snapshot] successfully activated snapshot %s\n", base_blockhash.ToString()); |
5820 | 0 | LogPrintf("[snapshot] (%.2f MB)\n", |
5821 | 0 | m_snapshot_chainstate->CoinsTip().DynamicMemoryUsage() / (1000 * 1000)); |
5822 | |
|
5823 | 0 | this->MaybeRebalanceCaches(); |
5824 | 0 | return snapshot_start_block; |
5825 | 0 | } |
5826 | | |
5827 | | static void FlushSnapshotToDisk(CCoinsViewCache& coins_cache, bool snapshot_loaded) |
5828 | 0 | { |
5829 | 0 | LOG_TIME_MILLIS_WITH_CATEGORY_MSG_ONCE( |
5830 | 0 | strprintf("%s (%.2f MB)", |
5831 | 0 | snapshot_loaded ? "saving snapshot chainstate" : "flushing coins cache", |
5832 | 0 | coins_cache.DynamicMemoryUsage() / (1000 * 1000)), |
5833 | 0 | BCLog::LogFlags::ALL); |
5834 | |
|
5835 | 0 | coins_cache.Flush(); |
5836 | 0 | } |
5837 | | |
5838 | | struct StopHashingException : public std::exception |
5839 | | { |
5840 | | const char* what() const noexcept override |
5841 | 0 | { |
5842 | 0 | return "ComputeUTXOStats interrupted."; |
5843 | 0 | } |
5844 | | }; |
5845 | | |
5846 | | static void SnapshotUTXOHashBreakpoint(const util::SignalInterrupt& interrupt) |
5847 | 0 | { |
5848 | 0 | if (interrupt) throw StopHashingException(); Branch (5848:9): [True: 0, False: 0]
|
5849 | 0 | } |
5850 | | |
5851 | | util::Result<void> ChainstateManager::PopulateAndValidateSnapshot( |
5852 | | Chainstate& snapshot_chainstate, |
5853 | | AutoFile& coins_file, |
5854 | | const SnapshotMetadata& metadata) |
5855 | 0 | { |
5856 | | // It's okay to release cs_main before we're done using `coins_cache` because we know |
5857 | | // that nothing else will be referencing the newly created snapshot_chainstate yet. |
5858 | 0 | CCoinsViewCache& coins_cache = *WITH_LOCK(::cs_main, return &snapshot_chainstate.CoinsTip()); |
5859 | |
|
5860 | 0 | uint256 base_blockhash = metadata.m_base_blockhash; |
5861 | |
|
5862 | 0 | CBlockIndex* snapshot_start_block = WITH_LOCK(::cs_main, return m_blockman.LookupBlockIndex(base_blockhash)); |
5863 | |
|
5864 | 0 | if (!snapshot_start_block) { Branch (5864:9): [True: 0, False: 0]
|
5865 | | // Needed for ComputeUTXOStats to determine the |
5866 | | // height and to avoid a crash when base_blockhash.IsNull() |
5867 | 0 | return util::Error{strprintf(Untranslated("Did not find snapshot start blockheader %s"), |
5868 | 0 | base_blockhash.ToString())}; |
5869 | 0 | } |
5870 | | |
5871 | 0 | int base_height = snapshot_start_block->nHeight; |
5872 | 0 | const auto& maybe_au_data = GetParams().AssumeutxoForHeight(base_height); |
5873 | |
|
5874 | 0 | if (!maybe_au_data) { Branch (5874:9): [True: 0, False: 0]
|
5875 | 0 | return util::Error{strprintf(Untranslated("Assumeutxo height in snapshot metadata not recognized " |
5876 | 0 | "(%d) - refusing to load snapshot"), base_height)}; |
5877 | 0 | } |
5878 | | |
5879 | 0 | const AssumeutxoData& au_data = *maybe_au_data; |
5880 | | |
5881 | | // This work comparison is a duplicate check with the one performed later in |
5882 | | // ActivateSnapshot(), but is done so that we avoid doing the long work of staging |
5883 | | // a snapshot that isn't actually usable. |
5884 | 0 | if (WITH_LOCK(::cs_main, return !CBlockIndexWorkComparator()(ActiveTip(), snapshot_start_block))) { |
5885 | 0 | return util::Error{Untranslated("Work does not exceed active chainstate")}; |
5886 | 0 | } |
5887 | | |
5888 | 0 | const uint64_t coins_count = metadata.m_coins_count; |
5889 | 0 | uint64_t coins_left = metadata.m_coins_count; |
5890 | |
|
5891 | 0 | LogPrintf("[snapshot] loading %d coins from snapshot %s\n", coins_left, base_blockhash.ToString()); |
5892 | 0 | int64_t coins_processed{0}; |
5893 | |
|
5894 | 0 | while (coins_left > 0) { Branch (5894:12): [True: 0, False: 0]
|
5895 | 0 | try { |
5896 | 0 | Txid txid; |
5897 | 0 | coins_file >> txid; |
5898 | 0 | size_t coins_per_txid{0}; |
5899 | 0 | coins_per_txid = ReadCompactSize(coins_file); |
5900 | |
|
5901 | 0 | if (coins_per_txid > coins_left) { Branch (5901:17): [True: 0, False: 0]
|
5902 | 0 | return util::Error{Untranslated("Mismatch in coins count in snapshot metadata and actual snapshot data")}; |
5903 | 0 | } |
5904 | | |
5905 | 0 | for (size_t i = 0; i < coins_per_txid; i++) { Branch (5905:32): [True: 0, False: 0]
|
5906 | 0 | COutPoint outpoint; |
5907 | 0 | Coin coin; |
5908 | 0 | outpoint.n = static_cast<uint32_t>(ReadCompactSize(coins_file)); |
5909 | 0 | outpoint.hash = txid; |
5910 | 0 | coins_file >> coin; |
5911 | 0 | if (coin.nHeight > base_height || Branch (5911:21): [True: 0, False: 0]
|
5912 | 0 | outpoint.n >= std::numeric_limits<decltype(outpoint.n)>::max() // Avoid integer wrap-around in coinstats.cpp:ApplyHash Branch (5912:21): [True: 0, False: 0]
|
5913 | 0 | ) { |
5914 | 0 | return util::Error{strprintf(Untranslated("Bad snapshot data after deserializing %d coins"), |
5915 | 0 | coins_count - coins_left)}; |
5916 | 0 | } |
5917 | 0 | if (!MoneyRange(coin.out.nValue)) { Branch (5917:21): [True: 0, False: 0]
|
5918 | 0 | return util::Error{strprintf(Untranslated("Bad snapshot data after deserializing %d coins - bad tx out value"), |
5919 | 0 | coins_count - coins_left)}; |
5920 | 0 | } |
5921 | 0 | coins_cache.EmplaceCoinInternalDANGER(std::move(outpoint), std::move(coin)); |
5922 | |
|
5923 | 0 | --coins_left; |
5924 | 0 | ++coins_processed; |
5925 | |
|
5926 | 0 | if (coins_processed % 1000000 == 0) { Branch (5926:21): [True: 0, False: 0]
|
5927 | 0 | LogPrintf("[snapshot] %d coins loaded (%.2f%%, %.2f MB)\n", |
5928 | 0 | coins_processed, |
5929 | 0 | static_cast<float>(coins_processed) * 100 / static_cast<float>(coins_count), |
5930 | 0 | coins_cache.DynamicMemoryUsage() / (1000 * 1000)); |
5931 | 0 | } |
5932 | | |
5933 | | // Batch write and flush (if we need to) every so often. |
5934 | | // |
5935 | | // If our average Coin size is roughly 41 bytes, checking every 120,000 coins |
5936 | | // means <5MB of memory imprecision. |
5937 | 0 | if (coins_processed % 120000 == 0) { Branch (5937:21): [True: 0, False: 0]
|
5938 | 0 | if (m_interrupt) { Branch (5938:25): [True: 0, False: 0]
|
5939 | 0 | return util::Error{Untranslated("Aborting after an interrupt was requested")}; |
5940 | 0 | } |
5941 | | |
5942 | 0 | const auto snapshot_cache_state = WITH_LOCK(::cs_main, |
5943 | 0 | return snapshot_chainstate.GetCoinsCacheSizeState()); |
5944 | |
|
5945 | 0 | if (snapshot_cache_state >= CoinsCacheSizeState::CRITICAL) { Branch (5945:25): [True: 0, False: 0]
|
5946 | | // This is a hack - we don't know what the actual best block is, but that |
5947 | | // doesn't matter for the purposes of flushing the cache here. We'll set this |
5948 | | // to its correct value (`base_blockhash`) below after the coins are loaded. |
5949 | 0 | coins_cache.SetBestBlock(GetRandHash()); |
5950 | | |
5951 | | // No need to acquire cs_main since this chainstate isn't being used yet. |
5952 | 0 | FlushSnapshotToDisk(coins_cache, /*snapshot_loaded=*/false); |
5953 | 0 | } |
5954 | 0 | } |
5955 | 0 | } |
5956 | 0 | } catch (const std::ios_base::failure&) { |
5957 | 0 | return util::Error{strprintf(Untranslated("Bad snapshot format or truncated snapshot after deserializing %d coins"), |
5958 | 0 | coins_processed)}; |
5959 | 0 | } |
5960 | 0 | } |
5961 | | |
5962 | | // Important that we set this. This and the coins_cache accesses above are |
5963 | | // sort of a layer violation, but either we reach into the innards of |
5964 | | // CCoinsViewCache here or we have to invert some of the Chainstate to |
5965 | | // embed them in a snapshot-activation-specific CCoinsViewCache bulk load |
5966 | | // method. |
5967 | 0 | coins_cache.SetBestBlock(base_blockhash); |
5968 | |
|
5969 | 0 | bool out_of_coins{false}; |
5970 | 0 | try { |
5971 | 0 | std::byte left_over_byte; |
5972 | 0 | coins_file >> left_over_byte; |
5973 | 0 | } catch (const std::ios_base::failure&) { |
5974 | | // We expect an exception since we should be out of coins. |
5975 | 0 | out_of_coins = true; |
5976 | 0 | } |
5977 | 0 | if (!out_of_coins) { Branch (5977:9): [True: 0, False: 0]
|
5978 | 0 | return util::Error{strprintf(Untranslated("Bad snapshot - coins left over after deserializing %d coins"), |
5979 | 0 | coins_count)}; |
5980 | 0 | } |
5981 | | |
5982 | 0 | LogPrintf("[snapshot] loaded %d (%.2f MB) coins from snapshot %s\n", |
5983 | 0 | coins_count, |
5984 | 0 | coins_cache.DynamicMemoryUsage() / (1000 * 1000), |
5985 | 0 | base_blockhash.ToString()); |
5986 | | |
5987 | | // No need to acquire cs_main since this chainstate isn't being used yet. |
5988 | 0 | FlushSnapshotToDisk(coins_cache, /*snapshot_loaded=*/true); |
5989 | |
|
5990 | 0 | assert(coins_cache.GetBestBlock() == base_blockhash); |
5991 | | |
5992 | | // As above, okay to immediately release cs_main here since no other context knows |
5993 | | // about the snapshot_chainstate. |
5994 | 0 | CCoinsViewDB* snapshot_coinsdb = WITH_LOCK(::cs_main, return &snapshot_chainstate.CoinsDB()); |
5995 | |
|
5996 | 0 | std::optional<CCoinsStats> maybe_stats; |
5997 | |
|
5998 | 0 | try { |
5999 | 0 | maybe_stats = ComputeUTXOStats( |
6000 | 0 | CoinStatsHashType::HASH_SERIALIZED, snapshot_coinsdb, m_blockman, [&interrupt = m_interrupt] { SnapshotUTXOHashBreakpoint(interrupt); }); |
6001 | 0 | } catch (StopHashingException const&) { |
6002 | 0 | return util::Error{Untranslated("Aborting after an interrupt was requested")}; |
6003 | 0 | } |
6004 | 0 | if (!maybe_stats.has_value()) { Branch (6004:9): [True: 0, False: 0]
|
6005 | 0 | return util::Error{Untranslated("Failed to generate coins stats")}; |
6006 | 0 | } |
6007 | | |
6008 | | // Assert that the deserialized chainstate contents match the expected assumeutxo value. |
6009 | 0 | if (AssumeutxoHash{maybe_stats->hashSerialized} != au_data.hash_serialized) { Branch (6009:9): [True: 0, False: 0]
|
6010 | 0 | return util::Error{strprintf(Untranslated("Bad snapshot content hash: expected %s, got %s"), |
6011 | 0 | au_data.hash_serialized.ToString(), maybe_stats->hashSerialized.ToString())}; |
6012 | 0 | } |
6013 | | |
6014 | 0 | snapshot_chainstate.m_chain.SetTip(*snapshot_start_block); |
6015 | | |
6016 | | // The remainder of this function requires modifying data protected by cs_main. |
6017 | 0 | LOCK(::cs_main); |
6018 | | |
6019 | | // Fake various pieces of CBlockIndex state: |
6020 | 0 | CBlockIndex* index = nullptr; |
6021 | | |
6022 | | // Don't make any modifications to the genesis block since it shouldn't be |
6023 | | // necessary, and since the genesis block doesn't have normal flags like |
6024 | | // BLOCK_VALID_SCRIPTS set. |
6025 | 0 | constexpr int AFTER_GENESIS_START{1}; |
6026 | |
|
6027 | 0 | for (int i = AFTER_GENESIS_START; i <= snapshot_chainstate.m_chain.Height(); ++i) { Branch (6027:39): [True: 0, False: 0]
|
6028 | 0 | index = snapshot_chainstate.m_chain[i]; |
6029 | | |
6030 | | // Fake BLOCK_OPT_WITNESS so that Chainstate::NeedsRedownload() |
6031 | | // won't ask to rewind the entire assumed-valid chain on startup. |
6032 | 0 | if (DeploymentActiveAt(*index, *this, Consensus::DEPLOYMENT_SEGWIT)) { Branch (6032:13): [True: 0, False: 0]
|
6033 | 0 | index->nStatus |= BLOCK_OPT_WITNESS; |
6034 | 0 | } |
6035 | |
|
6036 | 0 | m_blockman.m_dirty_blockindex.insert(index); |
6037 | | // Changes to the block index will be flushed to disk after this call |
6038 | | // returns in `ActivateSnapshot()`, when `MaybeRebalanceCaches()` is |
6039 | | // called, since we've added a snapshot chainstate and therefore will |
6040 | | // have to downsize the IBD chainstate, which will result in a call to |
6041 | | // `FlushStateToDisk(ALWAYS)`. |
6042 | 0 | } |
6043 | |
|
6044 | 0 | assert(index); |
6045 | 0 | assert(index == snapshot_start_block); |
6046 | 0 | index->m_chain_tx_count = au_data.m_chain_tx_count; |
6047 | 0 | snapshot_chainstate.setBlockIndexCandidates.insert(snapshot_start_block); |
6048 | |
|
6049 | 0 | LogPrintf("[snapshot] validated snapshot (%.2f MB)\n", |
6050 | 0 | coins_cache.DynamicMemoryUsage() / (1000 * 1000)); |
6051 | 0 | return {}; |
6052 | 0 | } |
6053 | | |
6054 | | // Currently, this function holds cs_main for its duration, which could be for |
6055 | | // multiple minutes due to the ComputeUTXOStats call. This hold is necessary |
6056 | | // because we need to avoid advancing the background validation chainstate |
6057 | | // farther than the snapshot base block - and this function is also invoked |
6058 | | // from within ConnectTip, i.e. from within ActivateBestChain, so cs_main is |
6059 | | // held anyway. |
6060 | | // |
6061 | | // Eventually (TODO), we could somehow separate this function's runtime from |
6062 | | // maintenance of the active chain, but that will either require |
6063 | | // |
6064 | | // (i) setting `m_disabled` immediately and ensuring all chainstate accesses go |
6065 | | // through IsUsable() checks, or |
6066 | | // |
6067 | | // (ii) giving each chainstate its own lock instead of using cs_main for everything. |
6068 | | SnapshotCompletionResult ChainstateManager::MaybeCompleteSnapshotValidation() |
6069 | 0 | { |
6070 | 0 | AssertLockHeld(cs_main); |
6071 | 0 | if (m_ibd_chainstate.get() == &this->ActiveChainstate() || Branch (6071:9): [True: 0, False: 0]
|
6072 | 0 | !this->IsUsable(m_snapshot_chainstate.get()) || Branch (6072:13): [True: 0, False: 0]
|
6073 | 0 | !this->IsUsable(m_ibd_chainstate.get()) || Branch (6073:13): [True: 0, False: 0]
|
6074 | 0 | !m_ibd_chainstate->m_chain.Tip()) { Branch (6074:13): [True: 0, False: 0]
|
6075 | | // Nothing to do - this function only applies to the background |
6076 | | // validation chainstate. |
6077 | 0 | return SnapshotCompletionResult::SKIPPED; |
6078 | 0 | } |
6079 | 0 | const int snapshot_tip_height = this->ActiveHeight(); |
6080 | 0 | const int snapshot_base_height = *Assert(this->GetSnapshotBaseHeight()); |
6081 | 0 | const CBlockIndex& index_new = *Assert(m_ibd_chainstate->m_chain.Tip()); |
6082 | |
|
6083 | 0 | if (index_new.nHeight < snapshot_base_height) { Branch (6083:9): [True: 0, False: 0]
|
6084 | | // Background IBD not complete yet. |
6085 | 0 | return SnapshotCompletionResult::SKIPPED; |
6086 | 0 | } |
6087 | | |
6088 | 0 | assert(SnapshotBlockhash()); |
6089 | 0 | uint256 snapshot_blockhash = *Assert(SnapshotBlockhash()); |
6090 | |
|
6091 | 0 | auto handle_invalid_snapshot = [&]() EXCLUSIVE_LOCKS_REQUIRED(::cs_main) { |
6092 | 0 | bilingual_str user_error = strprintf(_( |
6093 | 0 | "%s failed to validate the -assumeutxo snapshot state. " |
6094 | 0 | "This indicates a hardware problem, or a bug in the software, or a " |
6095 | 0 | "bad software modification that allowed an invalid snapshot to be " |
6096 | 0 | "loaded. As a result of this, the node will shut down and stop using any " |
6097 | 0 | "state that was built on the snapshot, resetting the chain height " |
6098 | 0 | "from %d to %d. On the next " |
6099 | 0 | "restart, the node will resume syncing from %d " |
6100 | 0 | "without using any snapshot data. " |
6101 | 0 | "Please report this incident to %s, including how you obtained the snapshot. " |
6102 | 0 | "The invalid snapshot chainstate will be left on disk in case it is " |
6103 | 0 | "helpful in diagnosing the issue that caused this error."), |
6104 | 0 | PACKAGE_NAME, snapshot_tip_height, snapshot_base_height, snapshot_base_height, PACKAGE_BUGREPORT |
6105 | 0 | ); |
6106 | |
|
6107 | 0 | LogError("[snapshot] !!! %s\n", user_error.original); |
6108 | 0 | LogError("[snapshot] deleting snapshot, reverting to validated chain, and stopping node\n"); |
6109 | |
|
6110 | 0 | m_active_chainstate = m_ibd_chainstate.get(); |
6111 | 0 | m_snapshot_chainstate->m_disabled = true; |
6112 | 0 | assert(!this->IsUsable(m_snapshot_chainstate.get())); |
6113 | 0 | assert(this->IsUsable(m_ibd_chainstate.get())); |
6114 | | |
6115 | 0 | auto rename_result = m_snapshot_chainstate->InvalidateCoinsDBOnDisk(); |
6116 | 0 | if (!rename_result) { Branch (6116:13): [True: 0, False: 0]
|
6117 | 0 | user_error = strprintf(Untranslated("%s\n%s"), user_error, util::ErrorString(rename_result)); |
6118 | 0 | } |
6119 | |
|
6120 | 0 | GetNotifications().fatalError(user_error); |
6121 | 0 | }; |
6122 | |
|
6123 | 0 | if (index_new.GetBlockHash() != snapshot_blockhash) { Branch (6123:9): [True: 0, False: 0]
|
6124 | 0 | LogPrintf("[snapshot] supposed base block %s does not match the " |
6125 | 0 | "snapshot base block %s (height %d). Snapshot is not valid.\n", |
6126 | 0 | index_new.ToString(), snapshot_blockhash.ToString(), snapshot_base_height); |
6127 | 0 | handle_invalid_snapshot(); |
6128 | 0 | return SnapshotCompletionResult::BASE_BLOCKHASH_MISMATCH; |
6129 | 0 | } |
6130 | | |
6131 | 0 | assert(index_new.nHeight == snapshot_base_height); |
6132 | | |
6133 | 0 | int curr_height = m_ibd_chainstate->m_chain.Height(); |
6134 | |
|
6135 | 0 | assert(snapshot_base_height == curr_height); |
6136 | 0 | assert(snapshot_base_height == index_new.nHeight); |
6137 | 0 | assert(this->IsUsable(m_snapshot_chainstate.get())); |
6138 | 0 | assert(this->GetAll().size() == 2); |
6139 | | |
6140 | 0 | CCoinsViewDB& ibd_coins_db = m_ibd_chainstate->CoinsDB(); |
6141 | 0 | m_ibd_chainstate->ForceFlushStateToDisk(); |
6142 | |
|
6143 | 0 | const auto& maybe_au_data = m_options.chainparams.AssumeutxoForHeight(curr_height); |
6144 | 0 | if (!maybe_au_data) { Branch (6144:9): [True: 0, False: 0]
|
6145 | 0 | LogPrintf("[snapshot] assumeutxo data not found for height " |
6146 | 0 | "(%d) - refusing to validate snapshot\n", curr_height); |
6147 | 0 | handle_invalid_snapshot(); |
6148 | 0 | return SnapshotCompletionResult::MISSING_CHAINPARAMS; |
6149 | 0 | } |
6150 | | |
6151 | 0 | const AssumeutxoData& au_data = *maybe_au_data; |
6152 | 0 | std::optional<CCoinsStats> maybe_ibd_stats; |
6153 | 0 | LogPrintf("[snapshot] computing UTXO stats for background chainstate to validate " |
6154 | 0 | "snapshot - this could take a few minutes\n"); |
6155 | 0 | try { |
6156 | 0 | maybe_ibd_stats = ComputeUTXOStats( |
6157 | 0 | CoinStatsHashType::HASH_SERIALIZED, |
6158 | 0 | &ibd_coins_db, |
6159 | 0 | m_blockman, |
6160 | 0 | [&interrupt = m_interrupt] { SnapshotUTXOHashBreakpoint(interrupt); }); |
6161 | 0 | } catch (StopHashingException const&) { |
6162 | 0 | return SnapshotCompletionResult::STATS_FAILED; |
6163 | 0 | } |
6164 | | |
6165 | | // XXX note that this function is slow and will hold cs_main for potentially minutes. |
6166 | 0 | if (!maybe_ibd_stats) { Branch (6166:9): [True: 0, False: 0]
|
6167 | 0 | LogPrintf("[snapshot] failed to generate stats for validation coins db\n"); |
6168 | | // While this isn't a problem with the snapshot per se, this condition |
6169 | | // prevents us from validating the snapshot, so we should shut down and let the |
6170 | | // user handle the issue manually. |
6171 | 0 | handle_invalid_snapshot(); |
6172 | 0 | return SnapshotCompletionResult::STATS_FAILED; |
6173 | 0 | } |
6174 | 0 | const auto& ibd_stats = *maybe_ibd_stats; |
6175 | | |
6176 | | // Compare the background validation chainstate's UTXO set hash against the hard-coded |
6177 | | // assumeutxo hash we expect. |
6178 | | // |
6179 | | // TODO: For belt-and-suspenders, we could cache the UTXO set |
6180 | | // hash for the snapshot when it's loaded in its chainstate's leveldb. We could then |
6181 | | // reference that here for an additional check. |
6182 | 0 | if (AssumeutxoHash{ibd_stats.hashSerialized} != au_data.hash_serialized) { Branch (6182:9): [True: 0, False: 0]
|
6183 | 0 | LogPrintf("[snapshot] hash mismatch: actual=%s, expected=%s\n", |
6184 | 0 | ibd_stats.hashSerialized.ToString(), |
6185 | 0 | au_data.hash_serialized.ToString()); |
6186 | 0 | handle_invalid_snapshot(); |
6187 | 0 | return SnapshotCompletionResult::HASH_MISMATCH; |
6188 | 0 | } |
6189 | | |
6190 | 0 | LogPrintf("[snapshot] snapshot beginning at %s has been fully validated\n", |
6191 | 0 | snapshot_blockhash.ToString()); |
6192 | |
|
6193 | 0 | m_ibd_chainstate->m_disabled = true; |
6194 | 0 | this->MaybeRebalanceCaches(); |
6195 | |
|
6196 | 0 | return SnapshotCompletionResult::SUCCESS; |
6197 | 0 | } |
6198 | | |
6199 | | Chainstate& ChainstateManager::ActiveChainstate() const |
6200 | 46.2k | { |
6201 | 46.2k | LOCK(::cs_main); |
6202 | 46.2k | assert(m_active_chainstate); |
6203 | 46.2k | return *m_active_chainstate; |
6204 | 46.2k | } |
6205 | | |
6206 | | bool ChainstateManager::IsSnapshotActive() const |
6207 | 0 | { |
6208 | 0 | LOCK(::cs_main); |
6209 | 0 | return m_snapshot_chainstate && m_active_chainstate == m_snapshot_chainstate.get(); Branch (6209:12): [True: 0, False: 0]
Branch (6209:37): [True: 0, False: 0]
|
6210 | 0 | } |
6211 | | |
6212 | | void ChainstateManager::MaybeRebalanceCaches() |
6213 | 0 | { |
6214 | 0 | AssertLockHeld(::cs_main); |
6215 | 0 | bool ibd_usable = this->IsUsable(m_ibd_chainstate.get()); |
6216 | 0 | bool snapshot_usable = this->IsUsable(m_snapshot_chainstate.get()); |
6217 | 0 | assert(ibd_usable || snapshot_usable); |
6218 | | |
6219 | 0 | if (ibd_usable && !snapshot_usable) { Branch (6219:9): [True: 0, False: 0]
Branch (6219:23): [True: 0, False: 0]
|
6220 | | // Allocate everything to the IBD chainstate. This will always happen |
6221 | | // when we are not using a snapshot. |
6222 | 0 | m_ibd_chainstate->ResizeCoinsCaches(m_total_coinstip_cache, m_total_coinsdb_cache); |
6223 | 0 | } |
6224 | 0 | else if (snapshot_usable && !ibd_usable) { Branch (6224:14): [True: 0, False: 0]
Branch (6224:33): [True: 0, False: 0]
|
6225 | | // If background validation has completed and snapshot is our active chain... |
6226 | 0 | LogPrintf("[snapshot] allocating all cache to the snapshot chainstate\n"); |
6227 | | // Allocate everything to the snapshot chainstate. |
6228 | 0 | m_snapshot_chainstate->ResizeCoinsCaches(m_total_coinstip_cache, m_total_coinsdb_cache); |
6229 | 0 | } |
6230 | 0 | else if (ibd_usable && snapshot_usable) { Branch (6230:14): [True: 0, False: 0]
Branch (6230:28): [True: 0, False: 0]
|
6231 | | // If both chainstates exist, determine who needs more cache based on IBD status. |
6232 | | // |
6233 | | // Note: shrink caches first so that we don't inadvertently overwhelm available memory. |
6234 | 0 | if (IsInitialBlockDownload()) { Branch (6234:13): [True: 0, False: 0]
|
6235 | 0 | m_ibd_chainstate->ResizeCoinsCaches( |
6236 | 0 | m_total_coinstip_cache * 0.05, m_total_coinsdb_cache * 0.05); |
6237 | 0 | m_snapshot_chainstate->ResizeCoinsCaches( |
6238 | 0 | m_total_coinstip_cache * 0.95, m_total_coinsdb_cache * 0.95); |
6239 | 0 | } else { |
6240 | 0 | m_snapshot_chainstate->ResizeCoinsCaches( |
6241 | 0 | m_total_coinstip_cache * 0.05, m_total_coinsdb_cache * 0.05); |
6242 | 0 | m_ibd_chainstate->ResizeCoinsCaches( |
6243 | 0 | m_total_coinstip_cache * 0.95, m_total_coinsdb_cache * 0.95); |
6244 | 0 | } |
6245 | 0 | } |
6246 | 0 | } |
6247 | | |
6248 | | void ChainstateManager::ResetChainstates() |
6249 | 0 | { |
6250 | 0 | m_ibd_chainstate.reset(); |
6251 | 0 | m_snapshot_chainstate.reset(); |
6252 | 0 | m_active_chainstate = nullptr; |
6253 | 0 | } |
6254 | | |
6255 | | /** |
6256 | | * Apply default chain params to nullopt members. |
6257 | | * This helps to avoid coding errors around the accidental use of the compare |
6258 | | * operators that accept nullopt, thus ignoring the intended default value. |
6259 | | */ |
6260 | | static ChainstateManager::Options&& Flatten(ChainstateManager::Options&& opts) |
6261 | 0 | { |
6262 | 0 | if (!opts.check_block_index.has_value()) opts.check_block_index = opts.chainparams.DefaultConsistencyChecks(); Branch (6262:9): [True: 0, False: 0]
|
6263 | 0 | if (!opts.minimum_chain_work.has_value()) opts.minimum_chain_work = UintToArith256(opts.chainparams.GetConsensus().nMinimumChainWork); Branch (6263:9): [True: 0, False: 0]
|
6264 | 0 | if (!opts.assumed_valid_block.has_value()) opts.assumed_valid_block = opts.chainparams.GetConsensus().defaultAssumeValid; Branch (6264:9): [True: 0, False: 0]
|
6265 | 0 | return std::move(opts); |
6266 | 0 | } |
6267 | | |
6268 | | ChainstateManager::ChainstateManager(const util::SignalInterrupt& interrupt, Options options, node::BlockManager::Options blockman_options) |
6269 | 0 | : m_script_check_queue{/*batch_size=*/128, options.worker_threads_num}, |
6270 | 0 | m_interrupt{interrupt}, |
6271 | 0 | m_options{Flatten(std::move(options))}, |
6272 | 0 | m_blockman{interrupt, std::move(blockman_options)}, |
6273 | 0 | m_validation_cache{m_options.script_execution_cache_bytes, m_options.signature_cache_bytes} |
6274 | 0 | { |
6275 | 0 | } |
6276 | | |
6277 | | ChainstateManager::~ChainstateManager() |
6278 | 1 | { |
6279 | 1 | LOCK(::cs_main); |
6280 | | |
6281 | 1 | m_versionbitscache.Clear(); |
6282 | 1 | } |
6283 | | |
6284 | | bool ChainstateManager::DetectSnapshotChainstate() |
6285 | 0 | { |
6286 | 0 | assert(!m_snapshot_chainstate); |
6287 | 0 | std::optional<fs::path> path = node::FindSnapshotChainstateDir(m_options.datadir); |
6288 | 0 | if (!path) { Branch (6288:9): [True: 0, False: 0]
|
6289 | 0 | return false; |
6290 | 0 | } |
6291 | 0 | std::optional<uint256> base_blockhash = node::ReadSnapshotBaseBlockhash(*path); |
6292 | 0 | if (!base_blockhash) { Branch (6292:9): [True: 0, False: 0]
|
6293 | 0 | return false; |
6294 | 0 | } |
6295 | 0 | LogPrintf("[snapshot] detected active snapshot chainstate (%s) - loading\n", |
6296 | 0 | fs::PathToString(*path)); |
6297 | |
|
6298 | 0 | this->ActivateExistingSnapshot(*base_blockhash); |
6299 | 0 | return true; |
6300 | 0 | } |
6301 | | |
6302 | | Chainstate& ChainstateManager::ActivateExistingSnapshot(uint256 base_blockhash) |
6303 | 0 | { |
6304 | 0 | assert(!m_snapshot_chainstate); |
6305 | 0 | m_snapshot_chainstate = |
6306 | 0 | std::make_unique<Chainstate>(nullptr, m_blockman, *this, base_blockhash); |
6307 | 0 | LogPrintf("[snapshot] switching active chainstate to %s\n", m_snapshot_chainstate->ToString()); |
6308 | | |
6309 | | // Mempool is empty at this point because we're still in IBD. |
6310 | 0 | Assert(m_active_chainstate->m_mempool->size() == 0); |
6311 | 0 | Assert(!m_snapshot_chainstate->m_mempool); |
6312 | 0 | m_snapshot_chainstate->m_mempool = m_active_chainstate->m_mempool; |
6313 | 0 | m_active_chainstate->m_mempool = nullptr; |
6314 | 0 | m_active_chainstate = m_snapshot_chainstate.get(); |
6315 | 0 | return *m_snapshot_chainstate; |
6316 | 0 | } |
6317 | | |
6318 | | bool IsBIP30Repeat(const CBlockIndex& block_index) |
6319 | 0 | { |
6320 | 0 | return (block_index.nHeight==91842 && block_index.GetBlockHash() == uint256{"00000000000a4d0a398161ffc163c503763b1f4360639393e0e4c8e300e0caec"}) || Branch (6320:13): [True: 0, False: 0]
Branch (6320:43): [True: 0, False: 0]
|
6321 | 0 | (block_index.nHeight==91880 && block_index.GetBlockHash() == uint256{"00000000000743f190a18c5577a3c2d2a1f610ae9601ac046a38084ccb7cd721"}); Branch (6321:13): [True: 0, False: 0]
Branch (6321:43): [True: 0, False: 0]
|
6322 | 0 | } |
6323 | | |
6324 | | bool IsBIP30Unspendable(const CBlockIndex& block_index) |
6325 | 0 | { |
6326 | 0 | return (block_index.nHeight==91722 && block_index.GetBlockHash() == uint256{"00000000000271a2dc26e7667f8419f2e15416dc6955e5a6c6cdf3f2574dd08e"}) || Branch (6326:13): [True: 0, False: 0]
Branch (6326:43): [True: 0, False: 0]
|
6327 | 0 | (block_index.nHeight==91812 && block_index.GetBlockHash() == uint256{"00000000000af0aed4792b1acee3d966af36cf5def14935db8de83d6f9306f2f"}); Branch (6327:13): [True: 0, False: 0]
Branch (6327:43): [True: 0, False: 0]
|
6328 | 0 | } |
6329 | | |
6330 | | static fs::path GetSnapshotCoinsDBPath(Chainstate& cs) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) |
6331 | 0 | { |
6332 | 0 | AssertLockHeld(::cs_main); |
6333 | | // Should never be called on a non-snapshot chainstate. |
6334 | 0 | assert(cs.m_from_snapshot_blockhash); |
6335 | 0 | auto storage_path_maybe = cs.CoinsDB().StoragePath(); |
6336 | | // Should never be called with a non-existent storage path. |
6337 | 0 | assert(storage_path_maybe); |
6338 | 0 | return *storage_path_maybe; |
6339 | 0 | } |
6340 | | |
6341 | | util::Result<void> Chainstate::InvalidateCoinsDBOnDisk() |
6342 | 0 | { |
6343 | 0 | fs::path snapshot_datadir = GetSnapshotCoinsDBPath(*this); |
6344 | | |
6345 | | // Coins views no longer usable. |
6346 | 0 | m_coins_views.reset(); |
6347 | |
|
6348 | 0 | auto invalid_path = snapshot_datadir + "_INVALID"; |
6349 | 0 | std::string dbpath = fs::PathToString(snapshot_datadir); |
6350 | 0 | std::string target = fs::PathToString(invalid_path); |
6351 | 0 | LogPrintf("[snapshot] renaming snapshot datadir %s to %s\n", dbpath, target); |
6352 | | |
6353 | | // The invalid snapshot datadir is simply moved and not deleted because we may |
6354 | | // want to do forensics later during issue investigation. The user is instructed |
6355 | | // accordingly in MaybeCompleteSnapshotValidation(). |
6356 | 0 | try { |
6357 | 0 | fs::rename(snapshot_datadir, invalid_path); |
6358 | 0 | } catch (const fs::filesystem_error& e) { |
6359 | 0 | auto src_str = fs::PathToString(snapshot_datadir); |
6360 | 0 | auto dest_str = fs::PathToString(invalid_path); |
6361 | |
|
6362 | 0 | LogPrintf("%s: error renaming file '%s' -> '%s': %s\n", |
6363 | 0 | __func__, src_str, dest_str, e.what()); |
6364 | 0 | return util::Error{strprintf(_( |
6365 | 0 | "Rename of '%s' -> '%s' failed. " |
6366 | 0 | "You should resolve this by manually moving or deleting the invalid " |
6367 | 0 | "snapshot directory %s, otherwise you will encounter the same error again " |
6368 | 0 | "on the next startup."), |
6369 | 0 | src_str, dest_str, src_str)}; |
6370 | 0 | } |
6371 | 0 | return {}; |
6372 | 0 | } |
6373 | | |
6374 | | bool ChainstateManager::DeleteSnapshotChainstate() |
6375 | 0 | { |
6376 | 0 | AssertLockHeld(::cs_main); |
6377 | 0 | Assert(m_snapshot_chainstate); |
6378 | 0 | Assert(m_ibd_chainstate); |
6379 | |
|
6380 | 0 | fs::path snapshot_datadir = Assert(node::FindSnapshotChainstateDir(m_options.datadir)).value(); |
6381 | 0 | if (!DeleteCoinsDBFromDisk(snapshot_datadir, /*is_snapshot=*/ true)) { Branch (6381:9): [True: 0, False: 0]
|
6382 | 0 | LogPrintf("Deletion of %s failed. Please remove it manually to continue reindexing.\n", |
6383 | 0 | fs::PathToString(snapshot_datadir)); |
6384 | 0 | return false; |
6385 | 0 | } |
6386 | 0 | m_active_chainstate = m_ibd_chainstate.get(); |
6387 | 0 | m_active_chainstate->m_mempool = m_snapshot_chainstate->m_mempool; |
6388 | 0 | m_snapshot_chainstate.reset(); |
6389 | 0 | return true; |
6390 | 0 | } |
6391 | | |
6392 | | ChainstateRole Chainstate::GetRole() const |
6393 | 0 | { |
6394 | 0 | if (m_chainman.GetAll().size() <= 1) { Branch (6394:9): [True: 0, False: 0]
|
6395 | 0 | return ChainstateRole::NORMAL; |
6396 | 0 | } |
6397 | 0 | return (this != &m_chainman.ActiveChainstate()) ? Branch (6397:12): [True: 0, False: 0]
|
6398 | 0 | ChainstateRole::BACKGROUND : |
6399 | 0 | ChainstateRole::ASSUMEDVALID; |
6400 | 0 | } |
6401 | | |
6402 | | const CBlockIndex* ChainstateManager::GetSnapshotBaseBlock() const |
6403 | 6.84k | { |
6404 | 6.84k | return m_active_chainstate ? m_active_chainstate->SnapshotBase() : nullptr; Branch (6404:12): [True: 6.84k, False: 0]
|
6405 | 6.84k | } |
6406 | | |
6407 | | std::optional<int> ChainstateManager::GetSnapshotBaseHeight() const |
6408 | 0 | { |
6409 | 0 | const CBlockIndex* base = this->GetSnapshotBaseBlock(); |
6410 | 0 | return base ? std::make_optional(base->nHeight) : std::nullopt; Branch (6410:12): [True: 0, False: 0]
|
6411 | 0 | } |
6412 | | |
6413 | | bool ChainstateManager::ValidatedSnapshotCleanup() |
6414 | 0 | { |
6415 | 0 | AssertLockHeld(::cs_main); |
6416 | 0 | auto get_storage_path = [](auto& chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) -> std::optional<fs::path> { |
6417 | 0 | if (!(chainstate && chainstate->HasCoinsViews())) { Branch (6417:15): [True: 0, False: 0]
Branch (6417:29): [True: 0, False: 0]
|
6418 | 0 | return {}; |
6419 | 0 | } |
6420 | 0 | return chainstate->CoinsDB().StoragePath(); |
6421 | 0 | }; |
6422 | 0 | std::optional<fs::path> ibd_chainstate_path_maybe = get_storage_path(m_ibd_chainstate); |
6423 | 0 | std::optional<fs::path> snapshot_chainstate_path_maybe = get_storage_path(m_snapshot_chainstate); |
6424 | |
|
6425 | 0 | if (!this->IsSnapshotValidated()) { Branch (6425:9): [True: 0, False: 0]
|
6426 | | // No need to clean up. |
6427 | 0 | return false; |
6428 | 0 | } |
6429 | | // If either path doesn't exist, that means at least one of the chainstates |
6430 | | // is in-memory, in which case we can't do on-disk cleanup. You'd better be |
6431 | | // in a unittest! |
6432 | 0 | if (!ibd_chainstate_path_maybe || !snapshot_chainstate_path_maybe) { Branch (6432:9): [True: 0, False: 0]
Branch (6432:39): [True: 0, False: 0]
|
6433 | 0 | LogPrintf("[snapshot] snapshot chainstate cleanup cannot happen with " |
6434 | 0 | "in-memory chainstates. You are testing, right?\n"); |
6435 | 0 | return false; |
6436 | 0 | } |
6437 | | |
6438 | 0 | const auto& snapshot_chainstate_path = *snapshot_chainstate_path_maybe; |
6439 | 0 | const auto& ibd_chainstate_path = *ibd_chainstate_path_maybe; |
6440 | | |
6441 | | // Since we're going to be moving around the underlying leveldb filesystem content |
6442 | | // for each chainstate, make sure that the chainstates (and their constituent |
6443 | | // CoinsViews members) have been destructed first. |
6444 | | // |
6445 | | // The caller of this method will be responsible for reinitializing chainstates |
6446 | | // if they want to continue operation. |
6447 | 0 | this->ResetChainstates(); |
6448 | | |
6449 | | // No chainstates should be considered usable. |
6450 | 0 | assert(this->GetAll().size() == 0); |
6451 | | |
6452 | 0 | LogPrintf("[snapshot] deleting background chainstate directory (now unnecessary) (%s)\n", |
6453 | 0 | fs::PathToString(ibd_chainstate_path)); |
6454 | |
|
6455 | 0 | fs::path tmp_old{ibd_chainstate_path + "_todelete"}; |
6456 | |
|
6457 | 0 | auto rename_failed_abort = [this]( |
6458 | 0 | fs::path p_old, |
6459 | 0 | fs::path p_new, |
6460 | 0 | const fs::filesystem_error& err) { |
6461 | 0 | LogError("[snapshot] Error renaming path (%s) -> (%s): %s\n", |
6462 | 0 | fs::PathToString(p_old), fs::PathToString(p_new), err.what()); |
6463 | 0 | GetNotifications().fatalError(strprintf(_( |
6464 | 0 | "Rename of '%s' -> '%s' failed. " |
6465 | 0 | "Cannot clean up the background chainstate leveldb directory."), |
6466 | 0 | fs::PathToString(p_old), fs::PathToString(p_new))); |
6467 | 0 | }; |
6468 | |
|
6469 | 0 | try { |
6470 | 0 | fs::rename(ibd_chainstate_path, tmp_old); |
6471 | 0 | } catch (const fs::filesystem_error& e) { |
6472 | 0 | rename_failed_abort(ibd_chainstate_path, tmp_old, e); |
6473 | 0 | throw; |
6474 | 0 | } |
6475 | | |
6476 | 0 | LogPrintf("[snapshot] moving snapshot chainstate (%s) to " |
6477 | 0 | "default chainstate directory (%s)\n", |
6478 | 0 | fs::PathToString(snapshot_chainstate_path), fs::PathToString(ibd_chainstate_path)); |
6479 | |
|
6480 | 0 | try { |
6481 | 0 | fs::rename(snapshot_chainstate_path, ibd_chainstate_path); |
6482 | 0 | } catch (const fs::filesystem_error& e) { |
6483 | 0 | rename_failed_abort(snapshot_chainstate_path, ibd_chainstate_path, e); |
6484 | 0 | throw; |
6485 | 0 | } |
6486 | | |
6487 | 0 | if (!DeleteCoinsDBFromDisk(tmp_old, /*is_snapshot=*/false)) { Branch (6487:9): [True: 0, False: 0]
|
6488 | | // No need to FatalError because once the unneeded bg chainstate data is |
6489 | | // moved, it will not interfere with subsequent initialization. |
6490 | 0 | LogPrintf("Deletion of %s failed. Please remove it manually, as the " |
6491 | 0 | "directory is now unnecessary.\n", |
6492 | 0 | fs::PathToString(tmp_old)); |
6493 | 0 | } else { |
6494 | 0 | LogPrintf("[snapshot] deleted background chainstate directory (%s)\n", |
6495 | 0 | fs::PathToString(ibd_chainstate_path)); |
6496 | 0 | } |
6497 | 0 | return true; |
6498 | 0 | } |
6499 | | |
6500 | | Chainstate& ChainstateManager::GetChainstateForIndexing() |
6501 | 0 | { |
6502 | | // We can't always return `m_ibd_chainstate` because after background validation |
6503 | | // has completed, `m_snapshot_chainstate == m_active_chainstate`, but it can be |
6504 | | // indexed. |
6505 | 0 | return (this->GetAll().size() > 1) ? *m_ibd_chainstate : *m_active_chainstate; Branch (6505:12): [True: 0, False: 0]
|
6506 | 0 | } |
6507 | | |
6508 | | std::pair<int, int> ChainstateManager::GetPruneRange(const Chainstate& chainstate, int last_height_can_prune) |
6509 | 0 | { |
6510 | 0 | if (chainstate.m_chain.Height() <= 0) { Branch (6510:9): [True: 0, False: 0]
|
6511 | 0 | return {0, 0}; |
6512 | 0 | } |
6513 | 0 | int prune_start{0}; |
6514 | |
|
6515 | 0 | if (this->GetAll().size() > 1 && m_snapshot_chainstate.get() == &chainstate) { Branch (6515:9): [True: 0, False: 0]
Branch (6515:9): [True: 0, False: 0]
Branch (6515:38): [True: 0, False: 0]
|
6516 | | // Leave the blocks in the background IBD chain alone if we're pruning |
6517 | | // the snapshot chain. |
6518 | 0 | prune_start = *Assert(GetSnapshotBaseHeight()) + 1; |
6519 | 0 | } |
6520 | |
|
6521 | 0 | int max_prune = std::max<int>( |
6522 | 0 | 0, chainstate.m_chain.Height() - static_cast<int>(MIN_BLOCKS_TO_KEEP)); |
6523 | | |
6524 | | // last block to prune is the lesser of (caller-specified height, MIN_BLOCKS_TO_KEEP from the tip) |
6525 | | // |
6526 | | // While you might be tempted to prune the background chainstate more |
6527 | | // aggressively (i.e. fewer MIN_BLOCKS_TO_KEEP), this won't work with index |
6528 | | // building - specifically blockfilterindex requires undo data, and if |
6529 | | // we don't maintain this trailing window, we hit indexing failures. |
6530 | 0 | int prune_end = std::min(last_height_can_prune, max_prune); |
6531 | |
|
6532 | 0 | return {prune_start, prune_end}; |
6533 | 0 | } |