6#include <bitcoin-build-config.h>
102 "level 0 reads the blocks from disk",
103 "level 1 verifies block validity",
104 "level 2 verifies undo data",
105 "level 3 checks disconnection of tip blocks",
106 "level 4 tries to reconnect the blocks",
107 "each level includes the checks of the previous levels",
145 std::vector<CScriptCheck>* pvChecks =
nullptr)
158 const int nBlockHeight = active_chain_tip.nHeight + 1;
165 const int64_t nBlockTime{active_chain_tip.GetMedianTimePast()};
167 return IsFinalTx(tx, nBlockHeight, nBlockTime);
181std::optional<std::vector<int>> CalculatePrevHeights(
186 std::vector<int> prev_heights;
187 prev_heights.resize(tx.
vin.size());
188 for (
size_t i = 0; i < tx.
vin.size(); ++i) {
189 if (
auto coin{coins.
GetCoin(tx.
vin[i].prevout)}) {
209 auto prev_heights{CalculatePrevHeights(*tip, coins_view, tx)};
210 if (!prev_heights.has_value())
return std::nullopt;
213 next_tip.
pprev = tip;
231 int max_input_height{0};
232 for (
const int height : prev_heights.value()) {
234 if (height != next_tip.
nHeight) {
235 max_input_height = std::max(max_input_height, height);
273 int expired = pool.Expire(GetTime<std::chrono::seconds>() - pool.m_opts.expiry);
278 std::vector<COutPoint> vNoSpendsRemaining;
279 pool.TrimToSize(pool.m_opts.max_size_bytes, &vNoSpendsRemaining);
280 for (
const COutPoint& removed : vNoSpendsRemaining)
281 coins_cache.Uncache(removed);
287 if (active_chainstate.m_chainman.IsInitialBlockDownload()) {
292 if (active_chainstate.m_chain.Height() < active_chainstate.m_chainman.m_best_header->nHeight - 1) {
306 std::vector<Txid> vHashUpdate;
313 const auto queuedTx = disconnectpool.
take();
314 auto it = queuedTx.rbegin();
315 while (it != queuedTx.rend()) {
317 if (!fAddToMempool || (*it)->IsCoinBase() ||
319 true,
false).m_result_type !=
325 vHashUpdate.push_back((*it)->GetHash());
366 it->UpdateLockPoints(*new_lock_points);
373 if (it->GetSpendsCoinbase()) {
379 if (coin.IsCoinBase() && mempool_spend_height - coin.nHeight <
COINBASE_MATURITY) {
415 if (coin.
IsSpent())
return false;
445 m_viewmempool(&active_chainstate.CoinsTip(), m_pool),
446 m_active_chainstate(active_chainstate)
454 const int64_t m_accept_time;
455 const bool m_bypass_limits;
463 std::vector<COutPoint>& m_coins_to_uncache;
465 const bool m_test_accept;
469 const bool m_allow_replacement;
471 const bool m_allow_sibling_eviction;
474 const bool m_package_submission;
478 const bool m_package_feerates;
483 const std::optional<CFeeRate> m_client_maxfeerate;
486 const bool m_allow_carveouts;
489 static ATMPArgs SingleAccept(
const CChainParams& chainparams, int64_t accept_time,
490 bool bypass_limits, std::vector<COutPoint>& coins_to_uncache,
492 return ATMPArgs{ chainparams,
507 static ATMPArgs PackageTestAccept(
const CChainParams& chainparams, int64_t accept_time,
508 std::vector<COutPoint>& coins_to_uncache) {
509 return ATMPArgs{ chainparams,
524 static ATMPArgs PackageChildWithParents(
const CChainParams& chainparams, int64_t accept_time,
525 std::vector<COutPoint>& coins_to_uncache,
const std::optional<CFeeRate>& client_maxfeerate) {
526 return ATMPArgs{ chainparams,
541 static ATMPArgs SingleInPackageAccept(
const ATMPArgs& package_args) {
542 return ATMPArgs{ package_args.m_chainparams,
543 package_args.m_accept_time,
545 package_args.m_coins_to_uncache,
546 package_args.m_test_accept,
551 package_args.m_client_maxfeerate,
562 std::vector<COutPoint>& coins_to_uncache,
564 bool allow_replacement,
565 bool allow_sibling_eviction,
566 bool package_submission,
567 bool package_feerates,
568 std::optional<CFeeRate> client_maxfeerate,
569 bool allow_carveouts)
570 : m_chainparams{chainparams},
571 m_accept_time{accept_time},
572 m_bypass_limits{bypass_limits},
573 m_coins_to_uncache{coins_to_uncache},
574 m_test_accept{test_accept},
575 m_allow_replacement{allow_replacement},
576 m_allow_sibling_eviction{allow_sibling_eviction},
577 m_package_submission{package_submission},
578 m_package_feerates{package_feerates},
579 m_client_maxfeerate{client_maxfeerate},
580 m_allow_carveouts{allow_carveouts}
584 if (m_package_feerates) {
585 Assume(m_package_submission);
586 Assume(!m_allow_carveouts);
587 Assume(!m_allow_sibling_eviction);
589 if (m_allow_sibling_eviction)
Assume(m_allow_replacement);
629 explicit Workspace(
const CTransactionRef& ptx) : m_ptx(ptx), m_hash(ptx->GetHash()) {}
632 std::set<Txid> m_conflicts;
642 bool m_sibling_eviction{
false};
677 bool PackageMempoolChecks(
const std::vector<CTransactionRef>& txns,
678 std::vector<Workspace>& workspaces,
699 std::map<Wtxid, MempoolAcceptResult>& results)
707 CAmount mempoolRejectFee = m_pool.GetMinFee().GetFee(package_size);
708 if (mempoolRejectFee > 0 && package_fee < mempoolRejectFee) {
712 if (package_fee < m_pool.m_opts.min_relay_feerate.GetFee(package_size)) {
714 strprintf(
"%d < %d", package_fee, m_pool.m_opts.min_relay_feerate.GetFee(package_size)));
721 return m_active_chainstate.m_chainman.m_validation_cache;
753 struct SubPackageState {
755 CAmount m_total_modified_fees{0};
757 int64_t m_total_vsize{0};
764 std::list<CTransactionRef> m_replaced_transactions;
766 std::unique_ptr<CTxMemPool::ChangeSet> m_changeset;
771 size_t m_conflicting_size{0};
774 struct SubPackageState m_subpackage;
779 m_subpackage = SubPackageState{};
782 CleanupTemporaryCoins();
786bool MemPoolAccept::PreChecks(ATMPArgs&
args, Workspace& ws)
792 const Txid& hash = ws.m_hash;
795 const int64_t nAcceptTime =
args.m_accept_time;
796 const bool bypass_limits =
args.m_bypass_limits;
797 std::vector<COutPoint>& coins_to_uncache =
args.m_coins_to_uncache;
812 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)) {
830 }
else if (m_pool.exists(tx.
GetHash())) {
840 if (ptxConflicting) {
841 if (!
args.m_allow_replacement) {
845 ws.m_conflicts.insert(ptxConflicting->
GetHash());
849 m_view.SetBackend(m_viewmempool);
855 coins_to_uncache.push_back(txin.
prevout);
861 if (!m_view.HaveCoin(txin.
prevout)) {
876 m_view.GetBestBlock();
881 m_view.SetBackend(m_dummy);
883 assert(m_active_chainstate.m_blockman.LookupBlockIndex(m_view.GetBestBlock()) == m_active_chainstate.m_chain.Tip());
890 const std::optional<LockPoints> lock_points{
CalculateLockPointsAtTip(m_active_chainstate.m_chain.Tip(), m_view, tx)};
913 bool fSpendsCoinbase =
false;
915 const Coin &coin = m_view.AccessCoin(txin.
prevout);
917 fSpendsCoinbase =
true;
924 const uint64_t entry_sequence = bypass_limits ? 0 : m_pool.GetSequence();
925 if (!m_subpackage.m_changeset) {
926 m_subpackage.m_changeset = m_pool.GetChangeSet();
928 ws.m_tx_handle = m_subpackage.m_changeset->StageAddition(ptx, ws.m_base_fees, nAcceptTime, m_active_chainstate.m_chain.Height(), entry_sequence, fSpendsCoinbase, nSigOpsCost, lock_points.value());
931 ws.m_modified_fees = ws.m_tx_handle->GetModifiedFee();
933 ws.m_vsize = ws.m_tx_handle->GetTxSize();
936 if (m_pool.m_opts.require_standard) {
937 if (!
PreCheckEphemeralTx(*ptx, m_pool.m_opts.dust_relay_feerate, ws.m_base_fees, ws.m_modified_fees, state)) {
952 if (!bypass_limits && ws.m_ptx->version !=
TRUC_VERSION && ws.m_modified_fees < m_pool.m_opts.min_relay_feerate.GetFee(ws.m_vsize)) {
956 strprintf(
"%d < %d", ws.m_modified_fees, m_pool.m_opts.min_relay_feerate.GetFee(ws.m_vsize)));
961 if (!bypass_limits && !
args.m_package_feerates && !
CheckFeeRate(ws.m_vsize, ws.m_modified_fees, state))
return false;
963 ws.m_iters_conflicting = m_pool.GetIterSet(ws.m_conflicts);
970 if (ws.m_conflicts.size() == 1 &&
args.m_allow_carveouts) {
998 assert(ws.m_iters_conflicting.size() == 1);
1005 if (
auto ancestors{m_subpackage.m_changeset->CalculateMemPoolAncestors(ws.m_tx_handle, maybe_rbf_limits)}) {
1006 ws.m_ancestors = std::move(*ancestors);
1012 if (!
args.m_allow_carveouts) {
1037 if (
auto ancestors_retry{m_subpackage.m_changeset->CalculateMemPoolAncestors(ws.m_tx_handle, cpfp_carve_out_limits)}) {
1038 ws.m_ancestors = std::move(*ancestors_retry);
1047 if (!
args.m_bypass_limits) {
1048 if (
const auto err{
SingleTRUCChecks(ws.m_ptx, ws.m_ancestors, ws.m_conflicts, ws.m_vsize)}) {
1050 if (
args.m_allow_sibling_eviction && err->second !=
nullptr) {
1056 ws.m_conflicts.insert(err->second->GetHash());
1060 ws.m_iters_conflicting.insert(m_pool.GetIter(err->second->GetHash()).value());
1061 ws.m_sibling_eviction =
true;
1083 m_subpackage.m_rbf |= !ws.m_conflicts.empty();
1087bool MemPoolAccept::ReplacementChecks(Workspace& ws)
1093 const Txid& hash = ws.m_hash;
1096 CFeeRate newFeeRate(ws.m_modified_fees, ws.m_vsize);
1110 strprintf(
"insufficient fee%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1118 strprintf(
"too many potential replacements%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1123 Assume(!ws.m_sibling_eviction);
1125 strprintf(
"replacement-adds-unconfirmed%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1131 m_subpackage.m_conflicting_fees += it->GetModifiedFee();
1132 m_subpackage.m_conflicting_size += it->GetTxSize();
1134 if (
const auto err_string{
PaysForRBF(m_subpackage.m_conflicting_fees, ws.m_modified_fees, ws.m_vsize,
1135 m_pool.m_opts.incremental_relay_feerate, hash)}) {
1138 strprintf(
"insufficient fee%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1142 for (
auto it : all_conflicts) {
1143 m_subpackage.m_changeset->StageRemoval(it);
1148bool MemPoolAccept::PackageMempoolChecks(
const std::vector<CTransactionRef>& txns,
1149 std::vector<Workspace>& workspaces,
1150 const int64_t total_vsize,
1157 assert(std::all_of(txns.cbegin(), txns.cend(), [
this](
const auto& tx) { return !m_pool.exists(tx->GetHash()); }));
1159 assert(txns.size() == workspaces.size());
1161 auto result = m_pool.CheckPackageLimits(txns, total_vsize);
1168 if (!m_subpackage.m_rbf)
return true;
1179 for (
const auto& ws : workspaces) {
1180 if (!ws.m_ancestors.empty()) {
1187 for (Workspace& ws : workspaces) {
1189 direct_conflict_iters.merge(ws.m_iters_conflicting);
1192 const auto& parent_ws = workspaces[0];
1193 const auto& child_ws = workspaces[1];
1201 "package RBF failed: too many potential replacements", *err_string);
1206 m_subpackage.m_changeset->StageRemoval(it);
1207 m_subpackage.m_conflicting_fees += it->GetModifiedFee();
1208 m_subpackage.m_conflicting_size += it->GetTxSize();
1212 const Txid& child_hash = child_ws.m_ptx->GetHash();
1213 if (
const auto err_string{
PaysForRBF(m_subpackage.m_conflicting_fees,
1214 m_subpackage.m_total_modified_fees,
1215 m_subpackage.m_total_vsize,
1216 m_pool.m_opts.incremental_relay_feerate, child_hash)}) {
1218 "package RBF failed: insufficient anti-DoS fees", *err_string);
1223 const CFeeRate parent_feerate(parent_ws.m_modified_fees, parent_ws.m_vsize);
1224 const CFeeRate package_feerate(m_subpackage.m_total_modified_fees, m_subpackage.m_total_vsize);
1225 if (package_feerate <= parent_feerate) {
1227 "package RBF failed: package feerate is less than or equal to parent feerate",
1228 strprintf(
"package feerate %s <= parent feerate is %s", package_feerate.ToString(), parent_feerate.ToString()));
1235 "package RBF failed: " + err_tup.value().second,
"");
1238 LogDebug(
BCLog::TXPACKAGES,
"package RBF checks passed: parent %s (wtxid=%s), child %s (wtxid=%s), package hash (%s)\n",
1239 txns.front()->GetHash().ToString(), txns.front()->GetWitnessHash().ToString(),
1240 txns.back()->GetHash().ToString(), txns.back()->GetWitnessHash().ToString(),
1247bool MemPoolAccept::PolicyScriptChecks(
const ATMPArgs&
args, Workspace& ws)
1258 if (!
CheckInputScripts(tx, state, m_view, scriptVerifyFlags,
true,
false, ws.m_precomputed_txdata, GetValidationCache())) {
1270bool MemPoolAccept::ConsensusScriptChecks(
const ATMPArgs&
args, Workspace& ws)
1275 const Txid& hash = ws.m_hash;
1293 unsigned int currentBlockScriptVerifyFlags{
GetBlockScriptFlags(*m_active_chainstate.m_chain.Tip(), m_active_chainstate.m_chainman)};
1295 ws.m_precomputed_txdata, m_active_chainstate.CoinsTip(), GetValidationCache())) {
1296 LogPrintf(
"BUG! PLEASE REPORT THIS! CheckInputScripts failed against latest-block but not STANDARD flags %s, %s\n", hash.
ToString(), state.
ToString());
1303void MemPoolAccept::FinalizeSubpackage(
const ATMPArgs&
args)
1308 if (!m_subpackage.m_changeset->GetRemovals().empty())
Assume(
args.m_allow_replacement);
1312 std::string log_string =
strprintf(
"replacing mempool tx %s (wtxid=%s, fees=%s, vsize=%s). ",
1313 it->GetTx().GetHash().ToString(),
1314 it->GetTx().GetWitnessHash().ToString(),
1317 FeeFrac feerate{m_subpackage.m_total_modified_fees, int32_t(m_subpackage.m_total_vsize)};
1319 const bool replaced_with_tx{m_subpackage.m_changeset->GetTxCount() == 1};
1320 if (replaced_with_tx) {
1321 const CTransaction& tx = m_subpackage.m_changeset->GetAddedTxn(0);
1323 log_string +=
strprintf(
"New tx %s (wtxid=%s, fees=%s, vsize=%s)",
1329 tx_or_package_hash =
GetPackageHash(m_subpackage.m_changeset->GetAddedTxns());
1330 log_string +=
strprintf(
"New package %s with %lu txs, fees=%s, vsize=%s",
1331 tx_or_package_hash.ToString(),
1332 m_subpackage.m_changeset->GetTxCount(),
1339 it->GetTx().GetHash().data(),
1342 std::chrono::duration_cast<std::chrono::duration<std::uint64_t>>(it->GetTime()).count(),
1343 tx_or_package_hash.data(),
1348 m_subpackage.m_replaced_transactions.push_back(it->GetSharedTx());
1350 m_subpackage.m_changeset->Apply();
1351 m_subpackage.m_changeset.reset();
1354bool MemPoolAccept::SubmitPackage(
const ATMPArgs&
args, std::vector<Workspace>& workspaces,
1356 std::map<Wtxid, MempoolAcceptResult>& results)
1362 assert(std::all_of(workspaces.cbegin(), workspaces.cend(), [
this](
const auto& ws) { return !m_pool.exists(ws.m_ptx->GetHash()); }));
1364 bool all_submitted =
true;
1365 FinalizeSubpackage(
args);
1370 for (Workspace& ws : workspaces) {
1371 if (!ConsensusScriptChecks(
args, ws)) {
1375 all_submitted =
false;
1377 strprintf(
"BUG! PolicyScriptChecks succeeded but ConsensusScriptChecks failed: %s",
1378 ws.m_ptx->GetHash().ToString()));
1380 if (!m_subpackage.m_changeset) m_subpackage.m_changeset = m_pool.GetChangeSet();
1381 m_subpackage.m_changeset->StageRemoval(m_pool.GetIter(ws.m_ptx->GetHash()).value());
1384 if (!all_submitted) {
1385 Assume(m_subpackage.m_changeset);
1389 m_subpackage.m_changeset->Apply();
1390 m_subpackage.m_changeset.reset();
1394 std::vector<Wtxid> all_package_wtxids;
1395 all_package_wtxids.reserve(workspaces.size());
1396 std::transform(workspaces.cbegin(), workspaces.cend(), std::back_inserter(all_package_wtxids),
1397 [](
const auto& ws) { return ws.m_ptx->GetWitnessHash(); });
1399 if (!m_subpackage.m_replaced_transactions.empty()) {
1400 LogDebug(
BCLog::MEMPOOL,
"replaced %u mempool transactions with %u new one(s) for %s additional fees, %d delta bytes\n",
1401 m_subpackage.m_replaced_transactions.size(), workspaces.size(),
1402 m_subpackage.m_total_modified_fees - m_subpackage.m_conflicting_fees,
1403 m_subpackage.m_total_vsize -
static_cast<int>(m_subpackage.m_conflicting_size));
1407 for (Workspace& ws : workspaces) {
1408 auto iter = m_pool.GetIter(ws.m_ptx->GetHash());
1409 Assume(iter.has_value());
1410 const auto effective_feerate =
args.m_package_feerates ? ws.m_package_feerate :
1411 CFeeRate{ws.m_modified_fees,
static_cast<int32_t
>(ws.m_vsize)};
1412 const auto effective_feerate_wtxids =
args.m_package_feerates ? all_package_wtxids :
1413 std::vector<Wtxid>{ws.m_ptx->GetWitnessHash()};
1414 results.emplace(ws.m_ptx->GetWitnessHash(),
1416 ws.m_base_fees, effective_feerate, effective_feerate_wtxids));
1417 if (!m_pool.m_opts.signals)
continue;
1420 ws.m_vsize, (*iter)->GetHeight(),
1421 args.m_bypass_limits,
args.m_package_submission,
1423 m_pool.HasNoInputsOf(tx));
1424 m_pool.m_opts.signals->TransactionAddedToMempool(tx_info, m_pool.GetAndIncrementSequence());
1426 return all_submitted;
1435 const std::vector<Wtxid> single_wtxid{ws.m_ptx->GetWitnessHash()};
1437 if (!PreChecks(
args, ws)) {
1445 m_subpackage.m_total_vsize = ws.m_vsize;
1446 m_subpackage.m_total_modified_fees = ws.m_modified_fees;
1449 if (
args.m_client_maxfeerate &&
CFeeRate(ws.m_modified_fees, ws.m_vsize) >
args.m_client_maxfeerate.value()) {
1454 if (m_pool.m_opts.require_standard) {
1456 if (!
CheckEphemeralSpends({ptx}, m_pool.m_opts.dust_relay_feerate, m_pool, ws.m_state, dummy_wtxid)) {
1461 if (m_subpackage.m_rbf && !ReplacementChecks(ws)) {
1475 const CFeeRate effective_feerate{ws.m_modified_fees,
static_cast<int32_t
>(ws.m_vsize)};
1477 if (
args.m_test_accept) {
1479 ws.m_base_fees, effective_feerate, single_wtxid);
1482 FinalizeSubpackage(
args);
1485 if (!
args.m_package_submission && !
args.m_bypass_limits) {
1489 CleanupTemporaryCoins();
1491 if (!m_pool.exists(ws.m_hash)) {
1498 if (m_pool.m_opts.signals) {
1500 auto iter = m_pool.GetIter(tx.
GetHash());
1501 Assume(iter.has_value());
1503 ws.m_vsize, (*iter)->GetHeight(),
1504 args.m_bypass_limits,
args.m_package_submission,
1506 m_pool.HasNoInputsOf(tx));
1507 m_pool.m_opts.signals->TransactionAddedToMempool(tx_info, m_pool.GetAndIncrementSequence());
1510 if (!m_subpackage.m_replaced_transactions.empty()) {
1511 LogDebug(
BCLog::MEMPOOL,
"replaced %u mempool transactions with 1 new transaction for %s additional fees, %d delta bytes\n",
1512 m_subpackage.m_replaced_transactions.size(),
1513 ws.m_modified_fees - m_subpackage.m_conflicting_fees,
1514 ws.m_vsize -
static_cast<int>(m_subpackage.m_conflicting_size));
1518 effective_feerate, single_wtxid);
1529 std::vector<Workspace> workspaces{};
1530 workspaces.reserve(txns.size());
1531 std::transform(txns.cbegin(), txns.cend(), std::back_inserter(workspaces),
1532 [](
const auto& tx) { return Workspace(tx); });
1533 std::map<Wtxid, MempoolAcceptResult> results;
1538 for (Workspace& ws : workspaces) {
1539 if (!PreChecks(
args, ws)) {
1548 if (
args.m_client_maxfeerate &&
CFeeRate(ws.m_modified_fees, ws.m_vsize) >
args.m_client_maxfeerate.value()) {
1566 m_viewmempool.PackageAddTransaction(ws.m_ptx);
1571 for (Workspace& ws : workspaces) {
1587 m_subpackage.m_total_vsize = std::accumulate(workspaces.cbegin(), workspaces.cend(), int64_t{0},
1588 [](int64_t
sum,
auto& ws) { return sum + ws.m_vsize; });
1589 m_subpackage.m_total_modified_fees = std::accumulate(workspaces.cbegin(), workspaces.cend(),
CAmount{0},
1590 [](
CAmount sum,
auto& ws) { return sum + ws.m_modified_fees; });
1591 const CFeeRate package_feerate(m_subpackage.m_total_modified_fees, m_subpackage.m_total_vsize);
1592 std::vector<Wtxid> all_package_wtxids;
1593 all_package_wtxids.reserve(workspaces.size());
1594 std::transform(workspaces.cbegin(), workspaces.cend(), std::back_inserter(all_package_wtxids),
1595 [](
const auto& ws) { return ws.m_ptx->GetWitnessHash(); });
1597 if (
args.m_package_feerates &&
1598 !
CheckFeeRate(m_subpackage.m_total_vsize, m_subpackage.m_total_modified_fees, placeholder_state)) {
1606 if (txns.size() > 1 && !PackageMempoolChecks(txns, workspaces, m_subpackage.m_total_vsize, package_state)) {
1611 if (m_pool.m_opts.require_standard) {
1614 if (!
CheckEphemeralSpends(txns, m_pool.m_opts.dust_relay_feerate, m_pool, child_state, child_wtxid)) {
1621 for (Workspace& ws : workspaces) {
1622 ws.m_package_feerate = package_feerate;
1623 if (!PolicyScriptChecks(
args, ws)) {
1629 if (
args.m_test_accept) {
1630 const auto effective_feerate =
args.m_package_feerates ? ws.m_package_feerate :
1631 CFeeRate{ws.m_modified_fees,
static_cast<int32_t
>(ws.m_vsize)};
1632 const auto effective_feerate_wtxids =
args.m_package_feerates ? all_package_wtxids :
1633 std::vector<Wtxid>{ws.m_ptx->GetWitnessHash()};
1634 results.emplace(ws.m_ptx->GetWitnessHash(),
1636 ws.m_vsize, ws.m_base_fees, effective_feerate,
1637 effective_feerate_wtxids));
1643 if (!SubmitPackage(
args, workspaces, package_state, results)) {
1651void MemPoolAccept::CleanupTemporaryCoins()
1672 for (
const auto& outpoint : m_viewmempool.GetNonBaseCoins()) {
1675 m_view.Uncache(outpoint);
1678 m_viewmempool.Reset();
1686 if (subpackage.size() > 1) {
1687 return AcceptMultipleTransactions(subpackage,
args);
1689 const auto& tx = subpackage.front();
1690 ATMPArgs single_args = ATMPArgs::SingleInPackageAccept(
args);
1691 const auto single_res = AcceptSingleTransaction(tx, single_args);
1702 ClearSubPackageState();
1709 Assert(!package.empty());
1735 std::map<Wtxid, MempoolAcceptResult> results_final;
1739 std::map<Wtxid, MempoolAcceptResult> individual_results_nonfinal;
1741 bool quit_early{
false};
1742 std::vector<CTransactionRef> txns_package_eval;
1743 for (
const auto& tx : package) {
1745 const auto& txid = tx->
GetHash();
1749 if (m_pool.exists(wtxid)) {
1759 const auto& entry{*
Assert(m_pool.GetEntry(txid))};
1761 }
else if (m_pool.exists(txid)) {
1769 const auto& entry{*
Assert(m_pool.GetEntry(txid))};
1775 const auto single_package_res = AcceptSubPackage({tx},
args);
1776 const auto& single_res = single_package_res.m_tx_results.at(wtxid);
1780 assert(m_pool.exists(wtxid));
1781 results_final.emplace(wtxid, single_res);
1782 }
else if (package.size() == 1 ||
1796 individual_results_nonfinal.emplace(wtxid, single_res);
1798 individual_results_nonfinal.emplace(wtxid, single_res);
1799 txns_package_eval.push_back(tx);
1804 auto multi_submission_result = quit_early || txns_package_eval.empty() ?
PackageMempoolAcceptResult(package_state_quit_early, {}) :
1805 AcceptSubPackage(txns_package_eval,
args);
1811 ClearSubPackageState();
1818 for (
const auto& tx : package) {
1820 if (multi_submission_result.m_tx_results.count(wtxid) > 0) {
1822 Assume(results_final.count(wtxid) == 0);
1825 const auto& txresult = multi_submission_result.m_tx_results.at(wtxid);
1832 results_final.emplace(wtxid, txresult);
1834 }
else if (
const auto it{results_final.find(wtxid)}; it != results_final.end()) {
1838 Assume(individual_results_nonfinal.count(wtxid) == 0);
1840 if (!m_pool.exists(tx->
GetHash())) {
1845 results_final.erase(wtxid);
1848 }
else if (
const auto it{individual_results_nonfinal.find(wtxid)}; it != individual_results_nonfinal.end()) {
1851 results_final.emplace(wtxid, it->second);
1854 Assume(results_final.size() == package.size());
1861 int64_t accept_time,
bool bypass_limits,
bool test_accept)
1868 std::vector<COutPoint> coins_to_uncache;
1869 auto args = MemPoolAccept::ATMPArgs::SingleAccept(chainparams, accept_time, bypass_limits, coins_to_uncache, test_accept);
1877 for (
const COutPoint& hashTx : coins_to_uncache)
1880 tx->GetHash().data(),
1891 const Package& package,
bool test_accept,
const std::optional<CFeeRate>& client_maxfeerate)
1894 assert(!package.empty());
1895 assert(std::all_of(package.cbegin(), package.cend(), [](
const auto& tx){return tx != nullptr;}));
1897 std::vector<COutPoint> coins_to_uncache;
1902 auto args = MemPoolAccept::ATMPArgs::PackageTestAccept(chainparams,
GetTime(), coins_to_uncache);
1903 return MemPoolAccept(pool, active_chainstate).AcceptMultipleTransactions(package,
args);
1905 auto args = MemPoolAccept::ATMPArgs::PackageChildWithParents(chainparams,
GetTime(), coins_to_uncache, client_maxfeerate);
1906 return MemPoolAccept(pool, active_chainstate).AcceptPackage(package,
args);
1911 if (test_accept || result.m_state.IsInvalid()) {
1912 for (
const COutPoint& hashTx : coins_to_uncache) {
1931 nSubsidy >>= halvings;
1936 : m_dbview{
std::move(db_params),
std::move(options)},
1937 m_catcherview(&m_dbview) {}
1939void CoinsViews::InitCache()
1942 m_cacheview = std::make_unique<CCoinsViewCache>(&m_catcherview);
1949 std::optional<uint256> from_snapshot_blockhash)
1950 : m_mempool(mempool),
1951 m_blockman(blockman),
1952 m_chainman(chainman),
1953 m_from_snapshot_blockhash(from_snapshot_blockhash) {}
1955const CBlockIndex* Chainstate::SnapshotBase()
const
1959 return m_cached_snapshot_base;
1963 size_t cache_size_bytes,
1966 fs::path leveldb_name)
1975 .cache_bytes = cache_size_bytes,
1976 .memory_only = in_memory,
1977 .wipe_data = should_wipe,
1985void Chainstate::InitCoinsCache(
size_t cache_size_bytes)
2011 if (chain.Tip() ==
nullptr) {
2020 LogInfo(
"Leaving InitialBlockDownload (latching to false)");
2037 LogPrintf(
"%s: Warning: Found invalid chain at least ~6 blocks longer than our best chain.\nChain state database corruption likely.\n", __func__);
2040 _(
"Warning: We do not appear to fully agree with our peers! You may need to upgrade, or other nodes may need to upgrade."));
2053 SetBlockFailureFlags(pindexNew);
2058 LogPrintf(
"%s: invalid block=%s height=%d log2_work=%f date=%s\n", __func__,
2063 LogPrintf(
"%s: current best=%s height=%d log2_work=%f date=%s\n", __func__,
2101 if (
VerifyScript(scriptSig,
m_tx_out.
scriptPubKey, witness,
nFlags,
CachingTransactionSignatureChecker(
ptxTo,
nIn,
m_tx_out.
nValue,
cacheStore, *
m_signature_cache, *
txdata), &error)) {
2102 return std::nullopt;
2105 return std::make_pair(error, std::move(debug_str));
2110 : m_signature_cache{signature_cache_bytes}
2121 LogInfo(
"Using %zu MiB out of %zu MiB requested for script execution cache, able to store %zu elements",
2122 approx_size_bytes >> 20, script_execution_cache_bytes >> 20, num_elems);
2148 std::vector<CScriptCheck>* pvChecks)
2153 pvChecks->reserve(tx.
vin.size());
2170 std::vector<CTxOut> spent_outputs;
2171 spent_outputs.reserve(tx.
vin.size());
2173 for (
const auto& txin : tx.
vin) {
2177 spent_outputs.emplace_back(coin.
out);
2179 txdata.
Init(tx, std::move(spent_outputs));
2183 for (
unsigned int i = 0; i < tx.
vin.size(); i++) {
2194 pvChecks->emplace_back(std::move(check));
2195 }
else if (
auto result = check(); result.has_value()) {
2210 if (cacheFullScriptStore && !pvChecks) {
2238 if (undo.nHeight == 0) {
2244 undo.nHeight = alternate.
nHeight;
2269 LogError(
"DisconnectBlock(): failure reading undo data\n");
2273 if (blockUndo.
vtxundo.size() + 1 != block.
vtx.size()) {
2274 LogError(
"DisconnectBlock(): block and undo data inconsistent\n");
2284 bool fEnforceBIP30 = !((pindex->
nHeight==91722 && pindex->
GetBlockHash() ==
uint256{
"00000000000271a2dc26e7667f8419f2e15416dc6955e5a6c6cdf3f2574dd08e"}) ||
2285 (pindex->
nHeight==91812 && pindex->
GetBlockHash() ==
uint256{
"00000000000af0aed4792b1acee3d966af36cf5def14935db8de83d6f9306f2f"}));
2288 for (
int i = block.
vtx.size() - 1; i >= 0; i--) {
2292 bool is_bip30_exception = (is_coinbase && !fEnforceBIP30);
2296 for (
size_t o = 0; o < tx.
vout.size(); o++) {
2297 if (!tx.
vout[o].scriptPubKey.IsUnspendable()) {
2302 if (!is_bip30_exception) {
2313 LogError(
"DisconnectBlock(): transaction and undo data inconsistent\n");
2316 for (
unsigned int j = tx.
vin.size(); j > 0;) {
2387 const auto time_start{SteadyClock::now()};
2403 if (!
CheckBlock(block, state, params.GetConsensus(), !fJustCheck, !fJustCheck)) {
2415 uint256 hashPrevBlock = pindex->
pprev ==
nullptr ?
uint256() : pindex->pprev->GetBlockHash();
2422 if (block_hash == params.GetConsensus().hashGenesisBlock) {
2428 bool fScriptChecks =
true;
2437 if (it->second.GetAncestor(pindex->
nHeight) == pindex &&
2459 const auto time_1{SteadyClock::now()};
2460 m_chainman.time_check += time_1 - time_start;
2462 Ticks<MillisecondsDouble>(time_1 - time_start),
2504 static constexpr int BIP34_IMPLIES_BIP30_LIMIT = 1983702;
2536 fEnforceBIP30 = fEnforceBIP30 && (!pindexBIP34height || !(pindexBIP34height->
GetBlockHash() == params.GetConsensus().BIP34Hash));
2541 if (fEnforceBIP30 || pindex->
nHeight >= BIP34_IMPLIES_BIP30_LIMIT) {
2542 for (
const auto& tx : block.
vtx) {
2543 for (
size_t o = 0; o < tx->
vout.size(); o++) {
2546 "tried to overwrite transaction");
2553 int nLockTimeFlags = 0;
2561 const auto time_2{SteadyClock::now()};
2564 Ticks<MillisecondsDouble>(time_2 - time_1),
2569 LogInfo(
"%s signature validations at block #%d (%s).", fScriptChecks ?
"Enabling" :
"Disabling", pindex->
nHeight, block_hash.ToString());
2580 std::optional<CCheckQueueControl<CScriptCheck>> control;
2583 std::vector<PrecomputedTransactionData> txsdata(block.
vtx.size());
2585 std::vector<int> prevheights;
2588 int64_t nSigOpsCost = 0;
2589 blockundo.
vtxundo.reserve(block.
vtx.size() - 1);
2590 for (
unsigned int i = 0; i < block.
vtx.size(); i++)
2595 nInputs += tx.
vin.size();
2611 "accumulated fee in the block out of range");
2618 prevheights.resize(tx.
vin.size());
2619 for (
size_t j = 0; j < tx.
vin.size(); j++) {
2623 if (!
SequenceLocks(tx, nLockTimeFlags, prevheights, *pindex)) {
2642 bool fCacheResults = fJustCheck;
2648 std::vector<CScriptCheck> vChecks;
2650 if (tx_ok) control->Add(std::move(vChecks));
2664 blockundo.
vtxundo.emplace_back();
2668 const auto time_3{SteadyClock::now()};
2670 LogDebug(
BCLog::BENCH,
" - Connect %u transactions: %.2fms (%.3fms/tx, %.3fms/txin) [%.2fs (%.2fms/blk)]\n", (
unsigned)block.
vtx.size(),
2671 Ticks<MillisecondsDouble>(time_3 - time_2), Ticks<MillisecondsDouble>(time_3 - time_2) / block.
vtx.size(),
2672 nInputs <= 1 ? 0 : Ticks<MillisecondsDouble>(time_3 - time_2) / (nInputs - 1),
2673 Ticks<SecondsDouble>(
m_chainman.time_connect),
2677 if (block.
vtx[0]->GetValueOut() > blockReward && state.
IsValid()) {
2679 strprintf(
"coinbase pays too much (actual=%d vs limit=%d)", block.
vtx[0]->GetValueOut(), blockReward));
2682 auto parallel_result = control->Complete();
2683 if (parallel_result.has_value() && state.
IsValid()) {
2691 const auto time_4{SteadyClock::now()};
2693 LogDebug(
BCLog::BENCH,
" - Verify %u txins: %.2fms (%.3fms/txin) [%.2fs (%.2fms/blk)]\n", nInputs - 1,
2694 Ticks<MillisecondsDouble>(time_4 - time_2),
2695 nInputs <= 1 ? 0 : Ticks<MillisecondsDouble>(time_4 - time_2) / (nInputs - 1),
2696 Ticks<SecondsDouble>(
m_chainman.time_verify),
2703 if (!
m_blockman.WriteBlockUndo(blockundo, state, *pindex)) {
2707 const auto time_5{SteadyClock::now()};
2710 Ticks<MillisecondsDouble>(time_5 - time_4),
2722 const auto time_6{SteadyClock::now()};
2725 Ticks<MillisecondsDouble>(time_6 - time_5),
2735 Ticks<std::chrono::nanoseconds>(time_5 - time_start)
2744 return this->GetCoinsCacheSizeState(
2750 size_t max_coins_cache_size_bytes,
2751 size_t max_mempool_size_bytes)
2756 int64_t nTotalSpace =
2757 max_coins_cache_size_bytes + std::max<int64_t>(int64_t(max_mempool_size_bytes) - nMempoolUsage, 0);
2759 if (cacheSize > nTotalSpace) {
2760 LogPrintf(
"Cache size (%s) exceeds total space (%s)\n", cacheSize, nTotalSpace);
2771 int nManualPruneHeight)
2775 std::set<int> setFilesToPrune;
2776 bool full_flush_completed =
false;
2783 bool fFlushForPrune =
false;
2791 std::optional<std::string> limiting_lock;
2793 for (
const auto& prune_lock :
m_blockman.m_prune_locks) {
2794 if (prune_lock.second.height_first == std::numeric_limits<int>::max())
continue;
2797 last_prune = std::max(1, std::min(last_prune, lock_height));
2798 if (last_prune == lock_height) {
2799 limiting_lock = prune_lock.first;
2803 if (limiting_lock) {
2804 LogDebug(
BCLog::PRUNE,
"%s limited pruning to height %d\n", limiting_lock.value(), last_prune);
2807 if (nManualPruneHeight > 0) {
2812 std::min(last_prune, nManualPruneHeight),
2820 if (!setFilesToPrune.empty()) {
2821 fFlushForPrune =
true;
2823 m_blockman.m_block_tree_db->WriteFlag(
"prunedblockfiles",
true);
2836 bool should_write = (mode ==
FlushStateMode::ALWAYS) || fCacheLarge || fCacheCritical || fPeriodicWrite || fFlushForPrune;
2839 LogDebug(
BCLog::COINDB,
"Writing chainstate to disk: flush mode=%s, prune=%d, large=%d, critical=%d, periodic=%d",
2840 FlushStateModeNames[
size_t(mode)], fFlushForPrune, fCacheLarge, fCacheCritical, fPeriodicWrite);
2866 if (fFlushForPrune) {
2872 if (!
CoinsTip().GetBestBlock().IsNull()) {
2873 if (coins_mem_usage >=
WARN_FLUSH_COINS_SIZE)
LogWarning(
"Flushing large (%d GiB) UTXO set to disk, it may take several minutes", coins_mem_usage >> 30);
2890 full_flush_completed =
true;
2892 int64_t{Ticks<std::chrono::microseconds>(
NodeClock::now() - nNow)},
2894 (uint64_t)coins_count,
2895 (uint64_t)coins_mem_usage,
2896 (
bool)fFlushForPrune);
2900 if (should_write ||
m_next_write == NodeClock::time_point::max()) {
2909 }
catch (
const std::runtime_error& e) {
2936 const std::string& func_name,
2937 const std::string&
prefix,
2949 chainman.GuessVerificationProgress(tip),
2952 !warning_messages.empty() ?
strprintf(
" warning='%s'", warning_messages) :
"");
2955void Chainstate::UpdateTip(
const CBlockIndex* pindexNew)
2958 const auto& coins_tip = this->
CoinsTip();
2964 constexpr int BACKGROUND_LOG_INTERVAL = 2000;
2965 if (pindexNew->
nHeight % BACKGROUND_LOG_INTERVAL == 0) {
2976 std::vector<bilingual_str> warning_messages;
2979 for (
auto [bit, active] : bits) {
2984 warning_messages.push_back(warning);
3011 std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
3014 LogError(
"DisconnectTip(): Failed to read block\n");
3018 const auto time_start{SteadyClock::now()};
3022 if (DisconnectBlock(block, pindexDelete, view) !=
DISCONNECT_OK) {
3026 bool flushed = view.
Flush();
3030 Ticks<MillisecondsDouble>(SteadyClock::now() - time_start));
3034 const int max_height_first{pindexDelete->
nHeight - 1};
3035 for (
auto& prune_lock :
m_blockman.m_prune_locks) {
3036 if (prune_lock.second.height_first <= max_height_first)
continue;
3038 prune_lock.second.height_first = max_height_first;
3039 LogDebug(
BCLog::PRUNE,
"%s prune lock moved back to %d\n", prune_lock.first, max_height_first);
3058 UpdateTip(pindexDelete->
pprev);
3116 std::shared_ptr<const CBlock> block_to_connect,
3125 const auto time_1{SteadyClock::now()};
3126 if (!block_to_connect) {
3127 std::shared_ptr<CBlock> pblockNew = std::make_shared<CBlock>();
3131 block_to_connect = std::move(pblockNew);
3136 const auto time_2{SteadyClock::now()};
3137 SteadyClock::time_point time_3;
3141 Ticks<MillisecondsDouble>(time_2 - time_1));
3144 bool rv =
ConnectBlock(*block_to_connect, state, pindexNew, view);
3154 time_3 = SteadyClock::now();
3155 m_chainman.time_connect_total += time_3 - time_2;
3158 Ticks<MillisecondsDouble>(time_3 - time_2),
3159 Ticks<SecondsDouble>(
m_chainman.time_connect_total),
3161 bool flushed = view.
Flush();
3164 const auto time_4{SteadyClock::now()};
3167 Ticks<MillisecondsDouble>(time_4 - time_3),
3174 const auto time_5{SteadyClock::now()};
3175 m_chainman.time_chainstate += time_5 - time_4;
3177 Ticks<MillisecondsDouble>(time_5 - time_4),
3178 Ticks<SecondsDouble>(
m_chainman.time_chainstate),
3187 UpdateTip(pindexNew);
3189 const auto time_6{SteadyClock::now()};
3190 m_chainman.time_post_connect += time_6 - time_5;
3193 Ticks<MillisecondsDouble>(time_6 - time_5),
3194 Ticks<SecondsDouble>(
m_chainman.time_post_connect),
3197 Ticks<MillisecondsDouble>(time_6 - time_1),
3206 m_chainman.MaybeCompleteSnapshotValidation();
3209 connectTrace.
BlockConnected(pindexNew, std::move(block_to_connect));
3234 bool fInvalidAncestor =
false;
3244 if (fFailedChain || fMissingData) {
3251 while (pindexTest != pindexFailed) {
3255 }
else if (fMissingData) {
3260 std::make_pair(pindexFailed->
pprev, pindexFailed));
3263 pindexFailed = pindexFailed->
pprev;
3266 fInvalidAncestor =
true;
3269 pindexTest = pindexTest->
pprev;
3271 if (!fInvalidAncestor)
3303 bool fBlocksDisconnected =
false;
3317 fBlocksDisconnected =
true;
3321 std::vector<CBlockIndex*> vpindexToConnect;
3322 bool fContinue =
true;
3327 int nTargetHeight = std::min(
nHeight + 32, pindexMostWork->
nHeight);
3328 vpindexToConnect.clear();
3329 vpindexToConnect.reserve(nTargetHeight -
nHeight);
3332 vpindexToConnect.push_back(pindexIter);
3333 pindexIter = pindexIter->
pprev;
3338 for (
CBlockIndex* pindexConnect : vpindexToConnect | std::views::reverse) {
3339 if (!
ConnectTip(state, pindexConnect, pindexConnect == pindexMostWork ? pblock : std::shared_ptr<const CBlock>(), connectTrace, disconnectpool)) {
3346 fInvalidFound =
true;
3367 if (fBlocksDisconnected) {
3388 bool fNotify =
false;
3389 bool fInitialBlockDownload =
false;
3393 pindexHeader = m_best_header;
3395 if (pindexHeader != m_last_notified_header) {
3398 m_last_notified_header = pindexHeader;
3411 if (signals.CallbacksPending() > 10) {
3412 signals.SyncWithValidationInterfaceQueue();
3416bool Chainstate::ActivateBestChain(
BlockValidationState& state, std::shared_ptr<const CBlock> pblock)
3435 LogPrintf(
"m_disabled is set - this chainstate should not be in operation. "
3436 "Please report this as a bug. %s\n", CLIENT_BUGREPORT);
3442 bool exited_ibd{
false};
3459 bool blocks_connected =
false;
3465 if (pindexMostWork ==
nullptr) {
3470 if (pindexMostWork ==
nullptr || pindexMostWork ==
m_chain.
Tip()) {
3474 bool fInvalidFound =
false;
3475 std::shared_ptr<const CBlock> nullBlockPtr;
3480 if (!
ActivateBestChainStep(state, pindexMostWork, pblock && pblock->GetHash() == pindexMostWork->
GetBlockHash() ? pblock : nullBlockPtr, fInvalidFound, connectTrace)) {
3484 blocks_connected =
true;
3486 if (fInvalidFound) {
3488 pindexMostWork =
nullptr;
3493 assert(trace.pblock && trace.pindex);
3508 if (!blocks_connected)
return true;
3513 if (was_in_ibd && !still_in_ibd) {
3573 }
while (pindexNewTip != pindexMostWork);
3613 return ActivateBestChain(state, std::shared_ptr<const CBlock>());
3623 if (pindex->
nHeight == 0)
return false;
3626 bool pindex_was_in_chain =
false;
3627 int disconnected = 0;
3641 std::multimap<const arith_uint256, CBlockIndex*> highpow_outofchain_headers;
3645 for (
auto& entry :
m_blockman.m_block_index) {
3655 highpow_outofchain_headers.insert({candidate->
nChainWork, candidate});
3672 pindex_was_in_chain =
true;
3685 if (!
ret)
return false;
3708 auto candidate_it = highpow_outofchain_headers.lower_bound(invalid_walk_tip->
pprev->
nChainWork);
3710 const bool best_header_needs_update{
m_chainman.m_best_header->GetAncestor(invalid_walk_tip->
nHeight) == invalid_walk_tip};
3711 if (best_header_needs_update) {
3716 while (candidate_it != highpow_outofchain_headers.end()) {
3720 candidate->nStatus &= ~BLOCK_FAILED_VALID;
3725 candidate_it = highpow_outofchain_headers.erase(candidate_it);
3735 if (best_header_needs_update &&
3744 to_mark_failed = invalid_walk_tip;
3770 for (
auto& [
_, block_index] :
m_blockman.m_block_index) {
3780 if (pindex_was_in_chain) {
3790 *to_mark_failed->
pprev,
3802void Chainstate::SetBlockFailureFlags(
CBlockIndex* invalid_block)
3806 for (
auto& [
_, block_index] :
m_blockman.m_block_index) {
3807 if (invalid_block != &block_index && block_index.GetAncestor(invalid_block->
nHeight) == invalid_block) {
3808 block_index.nStatus = (block_index.nStatus & ~BLOCK_FAILED_VALID) |
BLOCK_FAILED_CHILD;
3820 for (
auto& [
_, block_index] :
m_blockman.m_block_index) {
3822 block_index.nStatus &= ~BLOCK_FAILED_MASK;
3827 if (&block_index ==
m_chainman.m_best_invalid) {
3845 if (is_active_chainstate) {
3849 }
else if (!m_disabled) {
3854 if (snapshot_base->GetAncestor(pindex->
nHeight) == pindex) {
3864 pindexNew->
nTx = block.
vtx.size();
3870 auto prev_tx_sum = [](
CBlockIndex& block) {
return block.nTx + (block.pprev ? block.pprev->m_chain_tx_count : 0); };
3872 pindexNew == GetSnapshotBaseBlock())) {
3873 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",
3877 pindexNew->nFile = pos.
nFile;
3878 pindexNew->nDataPos = pos.
nPos;
3879 pindexNew->nUndoPos = 0;
3889 std::deque<CBlockIndex*> queue;
3890 queue.push_back(pindexNew);
3893 while (!queue.empty()) {
3901 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",
3907 c->TryAddBlockIndexCandidate(pindex);
3909 std::pair<std::multimap<CBlockIndex*, CBlockIndex*>::iterator, std::multimap<CBlockIndex*, CBlockIndex*>::iterator> range =
m_blockman.
m_blocks_unlinked.equal_range(pindex);
3910 while (range.first != range.second) {
3911 std::multimap<CBlockIndex*, CBlockIndex*>::iterator it = range.first;
3912 queue.push_back(it->second);
3943 "hashMerkleRoot mismatch");
3952 "bad-txns-duplicate",
3953 "duplicate transaction");
3968 if (expect_witness_commitment) {
3973 assert(!block.
vtx.empty() && !block.
vtx[0]->vin.empty());
3974 const auto& witness_stack{block.
vtx[0]->vin[0].scriptWitness.stack};
3976 if (witness_stack.size() != 1 || witness_stack[0].size() != 32) {
3979 "bad-witness-nonce-size",
3980 strprintf(
"%s : invalid witness reserved value size", __func__));
3989 if (memcmp(hash_witness.
begin(), &block.
vtx[0]->vout[commitpos].scriptPubKey[6], 32)) {
3992 "bad-witness-merkle-match",
3993 strprintf(
"%s : witness merkle commitment mismatch", __func__));
4002 for (
const auto& tx : block.
vtx) {
4006 "unexpected-witness",
4007 strprintf(
"%s : unexpected witness data found", __func__));
4047 if (block.
vtx.empty() || !block.
vtx[0]->IsCoinBase())
4049 for (
unsigned int i = 1; i < block.
vtx.size(); i++)
4050 if (block.
vtx[i]->IsCoinBase())
4055 for (
const auto& tx : block.
vtx) {
4067 unsigned int nSigOps = 0;
4068 for (
const auto& tx : block.
vtx)
4075 if (fCheckPOW && fCheckMerkleRoot)
4084 static const std::vector<unsigned char>
nonce(32, 0x00);
4087 tx.
vin[0].scriptWitness.stack.resize(1);
4088 tx.
vin[0].scriptWitness.stack[0] =
nonce;
4095 std::vector<unsigned char> commitment;
4097 std::vector<unsigned char>
ret(32, 0x00);
4105 out.scriptPubKey[1] = 0x24;
4106 out.scriptPubKey[2] = 0xaa;
4107 out.scriptPubKey[3] = 0x21;
4108 out.scriptPubKey[4] = 0xa9;
4109 out.scriptPubKey[5] = 0xed;
4110 memcpy(&
out.scriptPubKey[6], witnessroot.
begin(), 32);
4111 commitment = std::vector<unsigned char>(
out.scriptPubKey.begin(),
out.scriptPubKey.end());
4122 return std::all_of(headers.cbegin(), headers.cend(),
4123 [&](
const auto& header) { return CheckProofOfWork(header.GetHash(), header.nBits, consensusParams);});
4134 if (block.
vtx.empty() || !block.
vtx[0]->IsCoinBase()) {
4141 return std::any_of(block.
vtx.begin(), block.
vtx.end(),
4142 [](
auto& tx) { return GetSerializeSize(TX_NO_WITNESS(tx)) == 64; });
4183 assert(pindexPrev !=
nullptr);
4184 const int nHeight = pindexPrev->nHeight + 1;
4192 if (block.
GetBlockTime() <= pindexPrev->GetMedianTimePast())
4231 const int nHeight = pindexPrev ==
nullptr ? 0 : pindexPrev->
nHeight + 1;
4234 bool enforce_locktime_median_time_past{
false};
4236 assert(pindexPrev !=
nullptr);
4237 enforce_locktime_median_time_past =
true;
4240 const int64_t nLockTimeCutoff{enforce_locktime_median_time_past ?
4245 for (
const auto& tx : block.
vtx) {
4255 if (block.
vtx[0]->vin[0].scriptSig.size() <
expect.size() ||
4256 !std::equal(
expect.begin(),
expect.end(), block.
vtx[0]->vin[0].scriptSig.begin())) {
4292 BlockMap::iterator miSelf{
m_blockman.m_block_index.find(hash)};
4294 if (miSelf !=
m_blockman.m_block_index.end()) {
4318 pindexPrev = &((*mi).second);
4328 if (!min_pow_checked) {
4363 blocks_left = std::max<int64_t>(0, blocks_left);
4364 const double progress{100.0 * last_accepted.nHeight / (last_accepted.nHeight + blocks_left)};
4365 LogInfo(
"Synchronizing blockheaders, height: %d (~%.2f%%)\n", last_accepted.nHeight, progress);
4383 if (now < m_last_presync_update + std::chrono::milliseconds{250})
return;
4384 m_last_presync_update = now;
4388 if (initial_download) {
4390 blocks_left = std::max<int64_t>(0, blocks_left);
4391 const double progress{100.0 * height / (height + blocks_left)};
4392 LogInfo(
"Pre-synchronizing blockheaders, height: %d (~%.2f%%)\n", height, progress);
4399 const CBlock& block = *pblock;
4401 if (fNewBlock) *fNewBlock =
false;
4405 CBlockIndex *&pindex = ppindex ? *ppindex : pindexDummy;
4407 bool accepted_header{
AcceptBlockHeader(block, state, &pindex, min_pow_checked)};
4410 if (!accepted_header)
4434 if (fAlreadyHave)
return true;
4436 if (pindex->
nTx != 0)
return true;
4437 if (!fHasMoreOrSameWork)
return true;
4438 if (fTooFarAhead)
return true;
4449 if (!
CheckBlock(block, state, params.GetConsensus()) ||
4465 if (fNewBlock) *fNewBlock =
true;
4473 if (blockPos.IsNull()) {
4474 state.
Error(
strprintf(
"%s: Failed to find position to write new block to disk", __func__));
4479 }
catch (
const std::runtime_error& e) {
4503 if (new_block) *new_block =
false;
4518 ret =
AcceptBlock(block, state, &pindex, force_processing,
nullptr, new_block, min_pow_checked);
4533 LogError(
"%s: ActivateBestChain failed (%s)\n", __func__, state.
ToString());
4539 if (bg_chain && !bg_chain->ActivateBestChain(bg_state, block)) {
4540 LogError(
"%s: [background] ActivateBestChain failed (%s)\n", __func__, bg_state.
ToString());
4565 const bool check_pow,
4566 const bool check_merkle_root)
4577 state.
Invalid({},
"inconclusive-not-best-prevblk");
4618 index_dummy.pprev = tip;
4620 index_dummy.phashBlock = &block_hash;
4624 if(!chainstate.
ConnectBlock(block, state, &index_dummy, view_dummy,
true)) {
4665 LogInfo(
"Loaded best chain: hashBestChain=%s height=%d date=%s progress=%f",
4698 int nCheckLevel,
int nCheckDepth)
4707 if (nCheckDepth <= 0 || nCheckDepth > chainstate.
m_chain.
Height()) {
4710 nCheckLevel = std::max(0, std::min(4, nCheckLevel));
4711 LogInfo(
"Verifying last %i blocks at level %i", nCheckDepth, nCheckLevel);
4715 int nGoodTransactions = 0;
4718 bool skipped_no_block_data{
false};
4719 bool skipped_l3_checks{
false};
4720 LogInfo(
"Verification progress: 0%%");
4725 const int percentageDone = std::max(1, std::min(99, (
int)(((
double)(chainstate.
m_chain.
Height() - pindex->
nHeight)) / (
double)nCheckDepth * (nCheckLevel >= 4 ? 50 : 100))));
4726 if (reportDone < percentageDone / 10) {
4728 LogInfo(
"Verification progress: %d%%", percentageDone);
4729 reportDone = percentageDone / 10;
4738 LogInfo(
"Block verification stopping at height %d (no data). This could be due to pruning or use of an assumeutxo snapshot.", pindex->
nHeight);
4739 skipped_no_block_data =
true;
4749 if (nCheckLevel >= 1 && !
CheckBlock(block, state, consensus_params)) {
4750 LogPrintf(
"Verification error: found bad block at %d, hash=%s (%s)\n",
4755 if (nCheckLevel >= 2 && pindex) {
4767 if (nCheckLevel >= 3) {
4776 nGoodTransactions = 0;
4777 pindexFailure = pindex;
4779 nGoodTransactions += block.
vtx.size();
4782 skipped_l3_checks =
true;
4787 if (pindexFailure) {
4788 LogPrintf(
"Verification error: coin database inconsistencies found (last %i blocks, %i good transactions before that)\n", chainstate.
m_chain.
Height() - pindexFailure->
nHeight + 1, nGoodTransactions);
4791 if (skipped_l3_checks) {
4792 LogPrintf(
"Skipped verification of level >=3 (insufficient database cache size). Consider increasing -dbcache.\n");
4799 if (nCheckLevel >= 4 && !skipped_l3_checks) {
4801 const int percentageDone = std::max(1, std::min(99, 100 - (
int)(((
double)(chainstate.
m_chain.
Height() - pindex->
nHeight)) / (
double)nCheckDepth * 50)));
4802 if (reportDone < percentageDone / 10) {
4804 LogInfo(
"Verification progress: %d%%", percentageDone);
4805 reportDone = percentageDone / 10;
4814 if (!chainstate.
ConnectBlock(block, state, pindex, coins)) {
4822 LogInfo(
"Verification: No coin database inconsistencies in last %i blocks (%i transactions)", block_count, nGoodTransactions);
4824 if (skipped_l3_checks) {
4827 if (skipped_no_block_data) {
4845 if (!tx->IsCoinBase()) {
4846 for (
const CTxIn &txin : tx->vin) {
4864 if (hashHeads.empty())
return true;
4865 if (hashHeads.size() != 2) {
4866 LogError(
"ReplayBlocks(): unknown inconsistent state\n");
4877 if (
m_blockman.m_block_index.count(hashHeads[0]) == 0) {
4878 LogError(
"ReplayBlocks(): reorganization to unknown block requested\n");
4881 pindexNew = &(
m_blockman.m_block_index[hashHeads[0]]);
4883 if (!hashHeads[1].IsNull()) {
4884 if (
m_blockman.m_block_index.count(hashHeads[1]) == 0) {
4885 LogError(
"ReplayBlocks(): reorganization from unknown block requested\n");
4888 pindexOld = &(
m_blockman.m_block_index[hashHeads[1]]);
4890 assert(pindexFork !=
nullptr);
4894 while (pindexOld != pindexFork) {
4912 pindexOld = pindexOld->
pprev;
4916 int nForkHeight = pindexFork ? pindexFork->
nHeight : 0;
4943 block = block->pprev;
4949void Chainstate::ClearBlockIndexCandidates()
4961 if (!
ret)
return false;
4963 m_blockman.ScanAndUnlinkAlreadyPrunedFiles();
4965 std::vector<CBlockIndex*> vSortedByHeight{
m_blockman.GetAllBlockIndices()};
4966 std::sort(vSortedByHeight.begin(), vSortedByHeight.end(),
4976 if (pindex == GetSnapshotBaseBlock() ||
4981 chainstate->TryAddBlockIndexCandidate(pindex);
4985 m_best_invalid = pindex;
4988 m_best_header = pindex;
5004 if (
m_blockman.m_block_index.count(params.GenesisBlock().GetHash()))
5008 const CBlock& block = params.GenesisBlock();
5010 if (blockPos.IsNull()) {
5011 LogError(
"%s: writing genesis block to disk failed\n", __func__);
5016 }
catch (
const std::runtime_error& e) {
5017 LogError(
"%s: failed to write genesis block: %s\n", __func__, e.what());
5027 std::multimap<uint256, FlatFilePos>* blocks_with_unknown_parent)
5030 assert(!dbp == !blocks_with_unknown_parent);
5032 const auto start{SteadyClock::now()};
5040 uint64_t nRewind = blkdat.GetPos();
5041 while (!blkdat.eof()) {
5044 blkdat.SetPos(nRewind);
5047 unsigned int nSize = 0;
5051 blkdat.FindByte(std::byte(params.MessageStart()[0]));
5052 nRewind = blkdat.GetPos() + 1;
5054 if (buf != params.MessageStart()) {
5061 }
catch (
const std::exception&) {
5068 const uint64_t nBlockPos{blkdat.GetPos()};
5070 dbp->
nPos = nBlockPos;
5071 blkdat.SetLimit(nBlockPos + nSize);
5077 nRewind = nBlockPos + nSize;
5078 blkdat.SkipTo(nRewind);
5080 std::shared_ptr<CBlock> pblock{};
5088 if (dbp && blocks_with_unknown_parent) {
5089 blocks_with_unknown_parent->emplace(header.
hashPrevBlock, *dbp);
5098 blkdat.SetPos(nBlockPos);
5099 pblock = std::make_shared<CBlock>();
5101 nRewind = blkdat.GetPos();
5104 if (
AcceptBlock(pblock, state,
nullptr,
true, dbp,
nullptr,
true)) {
5110 }
else if (hash != params.GetConsensus().hashGenesisBlock && pindex->
nHeight % 1000 == 0) {
5137 bool activation_failure =
false;
5138 for (
auto c :
GetAll()) {
5140 if (!c->ActivateBestChain(state, pblock)) {
5142 activation_failure =
true;
5146 if (activation_failure) {
5153 if (!blocks_with_unknown_parent)
continue;
5156 std::deque<uint256> queue;
5157 queue.push_back(hash);
5158 while (!queue.empty()) {
5161 auto range = blocks_with_unknown_parent->equal_range(head);
5162 while (range.first != range.second) {
5163 std::multimap<uint256, FlatFilePos>::iterator it = range.first;
5164 std::shared_ptr<CBlock> pblockrecursive = std::make_shared<CBlock>();
5166 const auto& block_hash{pblockrecursive->GetHash()};
5170 if (
AcceptBlock(pblockrecursive, dummy,
nullptr,
true, &it->second,
nullptr,
true)) {
5172 queue.push_back(block_hash);
5176 blocks_with_unknown_parent->erase(it);
5180 }
catch (
const std::exception& e) {
5192 LogDebug(
BCLog::REINDEX,
"%s: unexpected data at file offset 0x%x - %s. continuing\n", __func__, (nRewind - 1), e.what());
5195 }
catch (
const std::runtime_error& e) {
5198 LogInfo(
"Loaded %i blocks from external file in %dms", nLoaded, Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
5233 best_hdr_chain.
SetTip(*m_best_header);
5235 std::multimap<const CBlockIndex*, const CBlockIndex*> forward;
5236 for (
auto& [
_, block_index] :
m_blockman.m_block_index) {
5238 if (!best_hdr_chain.
Contains(&block_index)) {
5240 assert(block_index.pprev);
5241 forward.emplace(block_index.pprev, &block_index);
5255 const CBlockIndex* pindexFirstNeverProcessed =
nullptr;
5256 const CBlockIndex* pindexFirstNotTreeValid =
nullptr;
5257 const CBlockIndex* pindexFirstNotTransactionsValid =
nullptr;
5258 const CBlockIndex* pindexFirstNotChainValid =
nullptr;
5259 const CBlockIndex* pindexFirstNotScriptsValid =
nullptr;
5265 const CBlockIndex* snap_base{GetSnapshotBaseBlock()};
5266 const CBlockIndex *snap_first_missing{}, *snap_first_notx{}, *snap_first_notv{}, *snap_first_nocv{}, *snap_first_nosv{};
5267 auto snap_update_firsts = [&] {
5268 if (pindex == snap_base) {
5269 std::swap(snap_first_missing, pindexFirstMissing);
5270 std::swap(snap_first_notx, pindexFirstNeverProcessed);
5271 std::swap(snap_first_notv, pindexFirstNotTransactionsValid);
5272 std::swap(snap_first_nocv, pindexFirstNotChainValid);
5273 std::swap(snap_first_nosv, pindexFirstNotScriptsValid);
5277 while (pindex !=
nullptr) {
5279 if (pindexFirstInvalid ==
nullptr && pindex->nStatus &
BLOCK_FAILED_VALID) pindexFirstInvalid = pindex;
5280 if (pindexFirstMissing ==
nullptr && !(pindex->nStatus &
BLOCK_HAVE_DATA)) {
5281 pindexFirstMissing = pindex;
5283 if (pindexFirstNeverProcessed ==
nullptr && pindex->
nTx == 0) pindexFirstNeverProcessed = pindex;
5286 if (pindex->
pprev !=
nullptr) {
5287 if (pindexFirstNotTransactionsValid ==
nullptr &&
5289 pindexFirstNotTransactionsValid = pindex;
5292 if (pindexFirstNotChainValid ==
nullptr &&
5294 pindexFirstNotChainValid = pindex;
5297 if (pindexFirstNotScriptsValid ==
nullptr &&
5299 pindexFirstNotScriptsValid = pindex;
5304 if (pindex->
pprev ==
nullptr) {
5307 for (
const Chainstate* c : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) {
5308 if (c && c->m_chain.Genesis() !=
nullptr) {
5309 assert(pindex == c->m_chain.Genesis());
5319 assert(pindexFirstMissing == pindexFirstNeverProcessed);
5325 if (snap_base && snap_base->GetAncestor(pindex->
nHeight) == pindex) {
5335 assert((pindexFirstNotTransactionsValid ==
nullptr || pindex == snap_base) == pindex->
HaveNumChainTxs());
5339 assert(pindexFirstNotTreeValid ==
nullptr);
5343 if (pindexFirstInvalid ==
nullptr) {
5350 if (!pindex->
pprev) {
5365 for (
const Chainstate* c : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) {
5366 if (!c || c->m_chain.Tip() ==
nullptr)
continue;
5380 if (!
CBlockIndexWorkComparator()(pindex, c->m_chain.Tip()) && (pindexFirstNeverProcessed ==
nullptr || pindex == snap_base)) {
5384 if (pindexFirstInvalid ==
nullptr) {
5403 if (pindexFirstMissing ==
nullptr || pindex == c->m_chain.Tip() || pindex == c->SnapshotBase()) {
5423 bool foundInUnlinked =
false;
5424 while (rangeUnlinked.first != rangeUnlinked.second) {
5425 assert(rangeUnlinked.first->first == pindex->
pprev);
5426 if (rangeUnlinked.first->second == pindex) {
5427 foundInUnlinked =
true;
5430 rangeUnlinked.first++;
5432 if (pindex->
pprev && (pindex->nStatus &
BLOCK_HAVE_DATA) && pindexFirstNeverProcessed !=
nullptr && pindexFirstInvalid ==
nullptr) {
5437 if (pindexFirstMissing ==
nullptr)
assert(!foundInUnlinked);
5438 if (pindex->
pprev && (pindex->nStatus &
BLOCK_HAVE_DATA) && pindexFirstNeverProcessed ==
nullptr && pindexFirstMissing !=
nullptr) {
5449 for (
const Chainstate* c : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) {
5453 if (pindexFirstInvalid ==
nullptr) {
5454 if (is_active || snap_base->GetAncestor(pindex->
nHeight) == pindex) {
5466 snap_update_firsts();
5467 auto range{forward.equal_range(pindex)};
5468 if (range.first != range.second) {
5470 pindex = range.first->second;
5473 }
else if (best_hdr_chain.
Contains(pindex)) {
5476 pindex = best_hdr_chain[
nHeight];
5484 snap_update_firsts();
5486 if (pindex == pindexFirstInvalid) pindexFirstInvalid =
nullptr;
5487 if (pindex == pindexFirstMissing) pindexFirstMissing =
nullptr;
5488 if (pindex == pindexFirstNeverProcessed) pindexFirstNeverProcessed =
nullptr;
5489 if (pindex == pindexFirstNotTreeValid) pindexFirstNotTreeValid =
nullptr;
5490 if (pindex == pindexFirstNotTransactionsValid) pindexFirstNotTransactionsValid =
nullptr;
5491 if (pindex == pindexFirstNotChainValid) pindexFirstNotChainValid =
nullptr;
5492 if (pindex == pindexFirstNotScriptsValid) pindexFirstNotScriptsValid =
nullptr;
5496 auto rangePar{forward.equal_range(pindexPar)};
5497 while (rangePar.first->second != pindex) {
5498 assert(rangePar.first != rangePar.second);
5503 if (rangePar.first != rangePar.second) {
5505 pindex = rangePar.first->second;
5507 }
else if (pindexPar == best_hdr_chain[
nHeight - 1]) {
5509 pindex = best_hdr_chain[
nHeight];
5511 assert((pindex ==
nullptr) == (pindexPar == best_hdr_chain.
Tip()));
5523 assert(nNodes == forward.size() + best_hdr_chain.
Height() + 1);
5530 return strprintf(
"Chainstate [%s] @ height %d (%s)",
5535bool Chainstate::ResizeCoinsCaches(
size_t coinstip_size,
size_t coinsdb_size)
5548 LogInfo(
"[%s] resized coinsdb cache to %.1f MiB",
5549 this->
ToString(), coinsdb_size * (1.0 / 1024 / 1024));
5550 LogInfo(
"[%s] resized coinstip cache to %.1f MiB",
5551 this->
ToString(), coinstip_size * (1.0 / 1024 / 1024));
5556 if (coinstip_size > old_coinstip_size) {
5570 if (pindex ==
nullptr) {
5579 const int64_t nNow{TicksSinceEpoch<std::chrono::seconds>(
NodeClock::now())};
5580 const auto block_time{
5581 (
Assume(m_best_header) && std::abs(nNow - pindex->
GetBlockTime()) <= Ticks<std::chrono::seconds>(2h) &&
5595 fTxTotal =
data.tx_count + (nNow -
data.nTime) *
data.dTxRate;
5606 if (m_active_chainstate && m_active_chainstate->m_from_snapshot_blockhash) {
5608 return m_active_chainstate->m_from_snapshot_blockhash;
5610 return std::nullopt;
5616 std::vector<Chainstate*>
out;
5618 for (
Chainstate*
cs : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) {
5628 assert(!m_ibd_chainstate);
5629 assert(!m_active_chainstate);
5631 m_ibd_chainstate = std::make_unique<Chainstate>(mempool,
m_blockman, *
this);
5632 m_active_chainstate = m_ibd_chainstate.get();
5633 return *m_active_chainstate;
5645 bool existed = fs::remove(base_blockhash_path);
5647 LogPrintf(
"[snapshot] snapshot chainstate dir being removed lacks %s file\n",
5650 }
catch (
const fs::filesystem_error& e) {
5651 LogWarning(
"[snapshot] failed to remove file %s: %s\n",
5657 LogInfo(
"Removing leveldb dir at %s\n", path_str);
5661 const bool destroyed =
DestroyDB(path_str);
5664 LogPrintf(
"error: leveldb DestroyDB call failed on %s\n", path_str);
5692 if (!
GetParams().AssumeutxoForBlockhash(base_blockhash).has_value()) {
5694 std::string heights_formatted =
util::Join(available_heights,
", ", [&](
const auto& i) {
return util::ToString(i); });
5695 return util::Error{
Untranslated(
strprintf(
"assumeutxo block hash in snapshot metadata not recognized (hash: %s). The following snapshot heights are available: %s",
5697 heights_formatted))};
5701 if (!snapshot_start_block) {
5702 return util::Error{
Untranslated(
strprintf(
"The base block header (%s) must appear in the headers chain. Make sure all headers are syncing, and call loadtxoutset again",
5707 if (start_block_invalid) {
5711 if (!m_best_header || m_best_header->GetAncestor(snapshot_start_block->nHeight) != snapshot_start_block) {
5712 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.")};
5715 auto mempool{m_active_chainstate->GetMempool()};
5716 if (mempool && mempool->
size() > 0) {
5721 int64_t current_coinsdb_cache_size{0};
5722 int64_t current_coinstip_cache_size{0};
5730 static constexpr double IBD_CACHE_PERC = 0.01;
5731 static constexpr double SNAPSHOT_CACHE_PERC = 0.99;
5743 current_coinsdb_cache_size = this->
ActiveChainstate().m_coinsdb_cache_size_bytes;
5744 current_coinstip_cache_size = this->
ActiveChainstate().m_coinstip_cache_size_bytes;
5749 static_cast<size_t>(current_coinstip_cache_size * IBD_CACHE_PERC),
5750 static_cast<size_t>(current_coinsdb_cache_size * IBD_CACHE_PERC));
5754 return std::make_unique<Chainstate>(
5755 nullptr,
m_blockman, *
this, base_blockhash));
5759 snapshot_chainstate->InitCoinsDB(
5760 static_cast<size_t>(current_coinsdb_cache_size * SNAPSHOT_CACHE_PERC),
5761 in_memory,
false,
"chainstate");
5762 snapshot_chainstate->InitCoinsCache(
5763 static_cast<size_t>(current_coinstip_cache_size * SNAPSHOT_CACHE_PERC));
5767 this->MaybeRebalanceCaches();
5775 snapshot_chainstate.reset();
5779 "Manually remove it before restarting.\n"),
fs::PathToString(*snapshot_datadir)));
5796 return cleanup_bad_snapshot(
Untranslated(
"work does not exceed active chainstate"));
5802 return cleanup_bad_snapshot(
Untranslated(
"could not write base blockhash"));
5806 assert(!m_snapshot_chainstate);
5807 m_snapshot_chainstate.swap(snapshot_chainstate);
5808 const bool chaintip_loaded = m_snapshot_chainstate->LoadChainTip();
5813 Assert(m_active_chainstate->m_mempool->size() == 0);
5814 Assert(!m_snapshot_chainstate->m_mempool);
5815 m_snapshot_chainstate->m_mempool = m_active_chainstate->m_mempool;
5816 m_active_chainstate->m_mempool =
nullptr;
5817 m_active_chainstate = m_snapshot_chainstate.get();
5820 LogInfo(
"[snapshot] successfully activated snapshot %s", base_blockhash.
ToString());
5821 LogInfo(
"[snapshot] (%.2f MB)",
5822 m_snapshot_chainstate->CoinsTip().DynamicMemoryUsage() / (1000 * 1000));
5824 this->MaybeRebalanceCaches();
5825 return snapshot_start_block;
5832 snapshot_loaded ?
"saving snapshot chainstate" :
"flushing coins cache",
5836 coins_cache.
Flush();
5841 const char*
what() const noexcept
override
5843 return "ComputeUTXOStats interrupted.";
5865 if (!snapshot_start_block) {
5872 int base_height = snapshot_start_block->
nHeight;
5875 if (!maybe_au_data) {
5877 "(%d) - refusing to load snapshot", base_height))};
5892 LogInfo(
"[snapshot] loading %d coins from snapshot %s", coins_left, base_blockhash.
ToString());
5893 int64_t coins_processed{0};
5895 while (coins_left > 0) {
5899 size_t coins_per_txid{0};
5902 if (coins_per_txid > coins_left) {
5906 for (
size_t i = 0; i < coins_per_txid; i++) {
5910 outpoint.
hash = txid;
5912 if (coin.
nHeight > base_height ||
5913 outpoint.
n >= std::numeric_limits<
decltype(outpoint.
n)>::max()
5916 coins_count - coins_left))};
5920 coins_count - coins_left))};
5927 if (coins_processed % 1000000 == 0) {
5928 LogInfo(
"[snapshot] %d coins loaded (%.2f%%, %.2f MB)",
5930 static_cast<float>(coins_processed) * 100 /
static_cast<float>(coins_count),
5938 if (coins_processed % 120000 == 0) {
5944 return snapshot_chainstate.GetCoinsCacheSizeState());
5957 }
catch (
const std::ios_base::failure&) {
5970 bool out_of_coins{
false};
5972 std::byte left_over_byte;
5973 coins_file >> left_over_byte;
5974 }
catch (
const std::ios_base::failure&) {
5976 out_of_coins =
true;
5978 if (!out_of_coins) {
5983 LogInfo(
"[snapshot] loaded %d (%.2f MB) coins from snapshot %s",
5997 std::optional<CCoinsStats> maybe_stats;
6005 if (!maybe_stats.has_value()) {
6026 constexpr int AFTER_GENESIS_START{1};
6028 for (
int i = AFTER_GENESIS_START; i <= snapshot_chainstate.
m_chain.
Height(); ++i) {
6029 index = snapshot_chainstate.
m_chain[i];
6046 assert(index == snapshot_start_block);
6050 LogInfo(
"[snapshot] validated snapshot (%.2f MB)",
6072 if (m_ibd_chainstate.get() == &this->ActiveChainstate() ||
6073 !this->IsUsable(m_snapshot_chainstate.get()) ||
6074 !this->IsUsable(m_ibd_chainstate.get()) ||
6075 !m_ibd_chainstate->m_chain.Tip()) {
6081 const int snapshot_base_height = *
Assert(this->GetSnapshotBaseHeight());
6084 if (index_new.
nHeight < snapshot_base_height) {
6094 "%s failed to validate the -assumeutxo snapshot state. "
6095 "This indicates a hardware problem, or a bug in the software, or a "
6096 "bad software modification that allowed an invalid snapshot to be "
6097 "loaded. As a result of this, the node will shut down and stop using any "
6098 "state that was built on the snapshot, resetting the chain height "
6099 "from %d to %d. On the next "
6100 "restart, the node will resume syncing from %d "
6101 "without using any snapshot data. "
6102 "Please report this incident to %s, including how you obtained the snapshot. "
6103 "The invalid snapshot chainstate will be left on disk in case it is "
6104 "helpful in diagnosing the issue that caused this error."),
6105 CLIENT_NAME, snapshot_tip_height, snapshot_base_height, snapshot_base_height, CLIENT_BUGREPORT
6109 LogError(
"[snapshot] deleting snapshot, reverting to validated chain, and stopping node\n");
6111 m_active_chainstate = m_ibd_chainstate.get();
6112 m_snapshot_chainstate->m_disabled =
true;
6116 auto rename_result = m_snapshot_chainstate->InvalidateCoinsDBOnDisk();
6117 if (!rename_result) {
6125 LogPrintf(
"[snapshot] supposed base block %s does not match the "
6126 "snapshot base block %s (height %d). Snapshot is not valid.\n",
6127 index_new.
ToString(), snapshot_blockhash.
ToString(), snapshot_base_height);
6128 handle_invalid_snapshot();
6134 int curr_height = m_ibd_chainstate->m_chain.Height();
6136 assert(snapshot_base_height == curr_height);
6141 CCoinsViewDB& ibd_coins_db = m_ibd_chainstate->CoinsDB();
6142 m_ibd_chainstate->ForceFlushStateToDisk();
6145 if (!maybe_au_data) {
6146 LogPrintf(
"[snapshot] assumeutxo data not found for height "
6147 "(%d) - refusing to validate snapshot\n", curr_height);
6148 handle_invalid_snapshot();
6153 std::optional<CCoinsStats> maybe_ibd_stats;
6154 LogInfo(
"[snapshot] computing UTXO stats for background chainstate to validate "
6155 "snapshot - this could take a few minutes");
6158 CoinStatsHashType::HASH_SERIALIZED,
6167 if (!maybe_ibd_stats) {
6168 LogPrintf(
"[snapshot] failed to generate stats for validation coins db\n");
6172 handle_invalid_snapshot();
6175 const auto& ibd_stats = *maybe_ibd_stats;
6184 LogPrintf(
"[snapshot] hash mismatch: actual=%s, expected=%s\n",
6185 ibd_stats.hashSerialized.ToString(),
6187 handle_invalid_snapshot();
6191 LogInfo(
"[snapshot] snapshot beginning at %s has been fully validated",
6194 m_ibd_chainstate->m_disabled =
true;
6195 this->MaybeRebalanceCaches();
6203 assert(m_active_chainstate);
6204 return *m_active_chainstate;
6210 return m_snapshot_chainstate && m_active_chainstate == m_snapshot_chainstate.get();
6213void ChainstateManager::MaybeRebalanceCaches()
6216 bool ibd_usable = this->
IsUsable(m_ibd_chainstate.get());
6217 bool snapshot_usable = this->
IsUsable(m_snapshot_chainstate.get());
6218 assert(ibd_usable || snapshot_usable);
6220 if (ibd_usable && !snapshot_usable) {
6225 else if (snapshot_usable && !ibd_usable) {
6227 LogInfo(
"[snapshot] allocating all cache to the snapshot chainstate");
6231 else if (ibd_usable && snapshot_usable) {
6236 m_ibd_chainstate->ResizeCoinsCaches(
6238 m_snapshot_chainstate->ResizeCoinsCaches(
6241 m_snapshot_chainstate->ResizeCoinsCaches(
6243 m_ibd_chainstate->ResizeCoinsCaches(
6249void ChainstateManager::ResetChainstates()
6251 m_ibd_chainstate.reset();
6252 m_snapshot_chainstate.reset();
6253 m_active_chainstate =
nullptr;
6263 if (!opts.check_block_index.has_value()) opts.
check_block_index = opts.chainparams.DefaultConsistencyChecks();
6264 if (!opts.minimum_chain_work.has_value()) opts.minimum_chain_work =
UintToArith256(opts.chainparams.GetConsensus().nMinimumChainWork);
6265 if (!opts.assumed_valid_block.has_value()) opts.assumed_valid_block = opts.chainparams.GetConsensus().defaultAssumeValid;
6266 return std::move(opts);
6271 m_interrupt{interrupt},
6273 m_blockman{interrupt,
std::move(blockman_options)},
6274 m_validation_cache{m_options.script_execution_cache_bytes, m_options.signature_cache_bytes}
6285bool ChainstateManager::DetectSnapshotChainstate()
6287 assert(!m_snapshot_chainstate);
6293 if (!base_blockhash) {
6296 LogInfo(
"[snapshot] detected active snapshot chainstate (%s) - loading",
6297 fs::PathToString(*path));
6299 this->ActivateExistingSnapshot(*base_blockhash);
6305 assert(!m_snapshot_chainstate);
6306 m_snapshot_chainstate =
6307 std::make_unique<Chainstate>(
nullptr,
m_blockman, *
this, base_blockhash);
6308 LogInfo(
"[snapshot] switching active chainstate to %s", m_snapshot_chainstate->ToString());
6311 Assert(m_active_chainstate->m_mempool->size() == 0);
6312 Assert(!m_snapshot_chainstate->m_mempool);
6313 m_snapshot_chainstate->m_mempool = m_active_chainstate->m_mempool;
6314 m_active_chainstate->m_mempool =
nullptr;
6315 m_active_chainstate = m_snapshot_chainstate.get();
6316 return *m_snapshot_chainstate;
6321 return (block_index.
nHeight==91842 && block_index.
GetBlockHash() ==
uint256{
"00000000000a4d0a398161ffc163c503763b1f4360639393e0e4c8e300e0caec"}) ||
6322 (block_index.
nHeight==91880 && block_index.
GetBlockHash() ==
uint256{
"00000000000743f190a18c5577a3c2d2a1f610ae9601ac046a38084ccb7cd721"});
6327 return (block_height==91722 && block_hash ==
uint256{
"00000000000271a2dc26e7667f8419f2e15416dc6955e5a6c6cdf3f2574dd08e"}) ||
6328 (block_height==91812 && block_hash ==
uint256{
"00000000000af0aed4792b1acee3d966af36cf5def14935db8de83d6f9306f2f"});
6335 assert(
cs.m_from_snapshot_blockhash);
6336 auto storage_path_maybe =
cs.CoinsDB().StoragePath();
6338 assert(storage_path_maybe);
6339 return *storage_path_maybe;
6349 auto invalid_path = snapshot_datadir +
"_INVALID";
6352 LogInfo(
"[snapshot] renaming snapshot datadir %s to %s", dbpath, target);
6358 fs::rename(snapshot_datadir, invalid_path);
6359 }
catch (
const fs::filesystem_error& e) {
6363 LogPrintf(
"%s: error renaming file '%s' -> '%s': %s\n",
6364 __func__, src_str, dest_str, e.what());
6366 "Rename of '%s' -> '%s' failed. "
6367 "You should resolve this by manually moving or deleting the invalid "
6368 "snapshot directory %s, otherwise you will encounter the same error again "
6369 "on the next startup."),
6370 src_str, dest_str, src_str)};
6375bool ChainstateManager::DeleteSnapshotChainstate()
6378 Assert(m_snapshot_chainstate);
6379 Assert(m_ibd_chainstate);
6383 LogPrintf(
"Deletion of %s failed. Please remove it manually to continue reindexing.\n",
6384 fs::PathToString(snapshot_datadir));
6387 m_active_chainstate = m_ibd_chainstate.get();
6388 m_active_chainstate->m_mempool = m_snapshot_chainstate->m_mempool;
6389 m_snapshot_chainstate.reset();
6403const CBlockIndex* ChainstateManager::GetSnapshotBaseBlock()
const
6405 return m_active_chainstate ? m_active_chainstate->SnapshotBase() :
nullptr;
6408std::optional<int> ChainstateManager::GetSnapshotBaseHeight()
const
6410 const CBlockIndex* base = this->GetSnapshotBaseBlock();
6411 return base ? std::make_optional(base->
nHeight) :
std::nullopt;
6414void ChainstateManager::RecalculateBestHeader()
6418 for (
auto& entry :
m_blockman.m_block_index) {
6419 if (!(entry.second.nStatus &
BLOCK_FAILED_MASK) && m_best_header->nChainWork < entry.second.nChainWork) {
6420 m_best_header = &entry.second;
6425bool ChainstateManager::ValidatedSnapshotCleanup()
6429 if (!(chainstate && chainstate->HasCoinsViews())) {
6432 return chainstate->CoinsDB().StoragePath();
6434 std::optional<fs::path> ibd_chainstate_path_maybe = get_storage_path(m_ibd_chainstate);
6435 std::optional<fs::path> snapshot_chainstate_path_maybe = get_storage_path(m_snapshot_chainstate);
6444 if (!ibd_chainstate_path_maybe || !snapshot_chainstate_path_maybe) {
6445 LogPrintf(
"[snapshot] snapshot chainstate cleanup cannot happen with "
6446 "in-memory chainstates. You are testing, right?\n");
6450 const auto& snapshot_chainstate_path = *snapshot_chainstate_path_maybe;
6451 const auto& ibd_chainstate_path = *ibd_chainstate_path_maybe;
6459 this->ResetChainstates();
6464 LogInfo(
"[snapshot] deleting background chainstate directory (now unnecessary) (%s)",
6465 fs::PathToString(ibd_chainstate_path));
6467 fs::path tmp_old{ibd_chainstate_path +
"_todelete"};
6469 auto rename_failed_abort = [
this](
6472 const fs::filesystem_error& err) {
6473 LogError(
"[snapshot] Error renaming path (%s) -> (%s): %s\n",
6474 fs::PathToString(p_old), fs::PathToString(p_new), err.what());
6476 "Rename of '%s' -> '%s' failed. "
6477 "Cannot clean up the background chainstate leveldb directory."),
6478 fs::PathToString(p_old), fs::PathToString(p_new)));
6482 fs::rename(ibd_chainstate_path, tmp_old);
6483 }
catch (
const fs::filesystem_error& e) {
6484 rename_failed_abort(ibd_chainstate_path, tmp_old, e);
6488 LogInfo(
"[snapshot] moving snapshot chainstate (%s) to "
6489 "default chainstate directory (%s)",
6490 fs::PathToString(snapshot_chainstate_path), fs::PathToString(ibd_chainstate_path));
6493 fs::rename(snapshot_chainstate_path, ibd_chainstate_path);
6494 }
catch (
const fs::filesystem_error& e) {
6495 rename_failed_abort(snapshot_chainstate_path, ibd_chainstate_path, e);
6502 LogPrintf(
"Deletion of %s failed. Please remove it manually, as the "
6503 "directory is now unnecessary.\n",
6504 fs::PathToString(tmp_old));
6506 LogInfo(
"[snapshot] deleted background chainstate directory (%s)",
6507 fs::PathToString(ibd_chainstate_path));
6512Chainstate& ChainstateManager::GetChainstateForIndexing()
6517 return (this->
GetAll().size() > 1) ? *m_ibd_chainstate : *m_active_chainstate;
6520std::pair<int, int> ChainstateManager::GetPruneRange(
const Chainstate& chainstate,
int last_height_can_prune)
6527 if (this->
GetAll().size() > 1 && m_snapshot_chainstate.get() == &chainstate) {
6530 prune_start = *
Assert(GetSnapshotBaseHeight()) + 1;
6533 int max_prune = std::max<int>(
6542 int prune_end = std::min(last_height_can_prune, max_prune);
6544 return {prune_start, prune_end};
bool MoneyRange(const CAmount &nValue)
int64_t CAmount
Amount in satoshis (Can be negative)
static constexpr CAmount COIN
The amount of satoshis in one BTC.
arith_uint256 UintToArith256(const uint256 &a)
void InvalidateBlock(ChainstateManager &chainman, const uint256 block_hash)
arith_uint256 GetBlockProof(const CBlockIndex &block)
CBlockLocator GetLocator(const CBlockIndex *index)
Get a locator for a block index entry.
int64_t GetBlockProofEquivalentTime(const CBlockIndex &to, const CBlockIndex &from, const CBlockIndex &tip, const Consensus::Params ¶ms)
Return the time it would take to redo the work difference between from and to, assuming the current h...
const CBlockIndex * LastCommonAncestor(const CBlockIndex *pa, const CBlockIndex *pb)
Find the last common ancestor two blocks have.
@ BLOCK_VALID_CHAIN
Outputs do not overspend inputs, no double spends, coinbase output ok, no immature coinbase spends,...
@ BLOCK_VALID_MASK
All validity bits.
@ BLOCK_VALID_TRANSACTIONS
Only first tx is coinbase, 2 <= coinbase input script length <= 100, transactions valid,...
@ BLOCK_VALID_SCRIPTS
Scripts & signatures ok.
@ BLOCK_VALID_TREE
All parent headers found, difficulty matches, timestamp >= median previous.
@ BLOCK_HAVE_UNDO
undo data available in rev*.dat
@ BLOCK_HAVE_DATA
full block available in blk*.dat
@ BLOCK_FAILED_CHILD
descends from failed block
@ BLOCK_FAILED_VALID
stage after last reached validness failed
@ BLOCK_OPT_WITNESS
block data in blk*.dat was received with a witness-enforcing client
#define NONFATAL_UNREACHABLE()
NONFATAL_UNREACHABLE() is a macro that is used to mark unreachable code.
#define Assert(val)
Identity function.
#define Assume(val)
Assume is the identity function.
Non-refcounted RAII wrapper for FILE*.
std::string ToString() const
Wrapper around an AutoFile& that implements a ring buffer to deserialize from.
bool m_checked_merkle_root
std::vector< CTransactionRef > vtx
bool m_checked_witness_commitment
The block chain is a tree shaped structure starting with the genesis block at the root,...
bool IsValid(enum BlockStatus nUpTo) const EXCLUSIVE_LOCKS_REQUIRED(
Check whether this block index entry is valid up to the passed validity level.
std::string ToString() const
CBlockIndex * pprev
pointer to the index of the predecessor of this block
uint64_t m_chain_tx_count
(memory only) Number of transactions in the chain up to and including this block.
arith_uint256 nChainWork
(memory only) Total amount of work (expected number of hashes) in the chain up to and including this ...
bool HaveNumChainTxs() const
Check whether this block and all previous blocks back to the genesis block or an assumeutxo snapshot ...
int32_t nSequenceId
(memory only) Sequential id assigned to distinguish order in which blocks are received.
uint256 GetBlockHash() const
int64_t GetBlockTime() const
int64_t GetMedianTimePast() const
FlatFilePos GetUndoPos() const EXCLUSIVE_LOCKS_REQUIRED(
bool RaiseValidity(enum BlockStatus nUpTo) EXCLUSIVE_LOCKS_REQUIRED(
Raise the validity level of this block index entry.
CBlockIndex * pskip
pointer to the index of some further predecessor of this block
unsigned int nTx
Number of transactions in this block.
int32_t nVersion
block header
CBlockIndex * GetAncestor(int height)
Efficiently find an ancestor of this block.
int nHeight
height of the entry in the chain. The genesis block has height 0
const uint256 * phashBlock
pointer to the hash of the block, if any. Memory is owned by this CBlockIndex
Undo information for a CBlock.
std::vector< CTxUndo > vtxundo
An in-memory indexed chain of blocks.
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
void SetTip(CBlockIndex &block)
Set/initialize a chain with a given tip.
CBlockIndex * Genesis() const
Returns the index entry for the genesis block of this chain, or nullptr if none.
CBlockIndex * Next(const CBlockIndex *pindex) const
Find the successor of a block in this chain, or nullptr if the given index is not found or is the tip...
int Height() const
Return the maximal height in the chain.
const CBlockIndex * FindFork(const CBlockIndex *pindex) const
Find the last common block between this chain and a block index entry.
bool Contains(const CBlockIndex *pindex) const
Efficiently check whether a block is present in this chain.
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
std::vector< int > GetAvailableSnapshotHeights() const
const ChainTxData & TxData() const
std::optional< AssumeutxoData > AssumeutxoForHeight(int height) const
CCoinsView that adds a memory cache for transactions to another CCoinsView.
bool SpendCoin(const COutPoint &outpoint, Coin *moveto=nullptr)
Spend a coin.
void Uncache(const COutPoint &outpoint)
Removes the UTXO with the given outpoint from the cache, if it is not modified.
void AddCoin(const COutPoint &outpoint, Coin &&coin, bool possible_overwrite)
Add a coin.
unsigned int GetCacheSize() const
Calculate the size of the cache (in number of transaction outputs)
uint256 GetBestBlock() const override
Retrieve the block hash whose state this CCoinsView currently represents.
void SetBestBlock(const uint256 &hashBlock)
bool HaveCoinInCache(const COutPoint &outpoint) const
Check if we have the given utxo already loaded in this cache.
bool Flush()
Push the modifications applied to this cache to its base and wipe local state.
size_t DynamicMemoryUsage() const
Calculate the size of the cache (in bytes)
bool Sync()
Push the modifications applied to this cache to its base while retaining the contents of this cache (...
void EmplaceCoinInternalDANGER(COutPoint &&outpoint, Coin &&coin)
Emplace a coin into cacheCoins without performing any checks, marking the emplaced coin as dirty.
bool HaveCoin(const COutPoint &outpoint) const override
Just check whether a given outpoint is unspent.
const Coin & AccessCoin(const COutPoint &output) const
Return a reference to Coin in the cache, or coinEmpty if not found.
CCoinsView backed by the coin database (chainstate/)
void ResizeCache(size_t new_cache_size) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Dynamically alter the underlying leveldb cache size.
Abstract view on the open txout dataset.
virtual std::optional< Coin > GetCoin(const COutPoint &outpoint) const
Retrieve the Coin (unspent transaction output) for a given outpoint.
virtual std::vector< uint256 > GetHeadBlocks() const
Retrieve the range of blocks that may have been only partially written.
CCoinsView that brings transactions from a mempool into view.
Fee rate in satoshis per virtualbyte: CAmount / vB the feerate is represented internally as FeeFrac.
A hasher class for Bitcoin's 256-bit hash (double SHA-256).
void Finalize(std::span< unsigned char > output)
CHash256 & Write(std::span< const unsigned char > input)
An outpoint - a combination of a transaction hash and an index n into its vout.
A hasher class for SHA-256.
void Finalize(unsigned char hash[OUTPUT_SIZE])
CSHA256 & Write(const unsigned char *data, size_t len)
Closure representing one script verification Note that this stores references to the spending transac...
SignatureCache * m_signature_cache
PrecomputedTransactionData * txdata
std::optional< std::pair< ScriptError, std::string > > operator()()
const CTransaction * ptxTo
Serialized script, used inside transaction inputs and outputs.
The basic transaction that is broadcasted on the network and contained in blocks.
const std::vector< CTxOut > vout
const Wtxid & GetWitnessHash() const LIFETIMEBOUND
const Txid & GetHash() const LIFETIMEBOUND
const std::vector< CTxIn > vin
An input of a transaction.
CTxMemPool::txiter TxHandle
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
RecursiveMutex cs
This mutex needs to be locked when accessing mapTx or other members that are guarded by it.
void check(const CCoinsViewCache &active_coins_tip, int64_t spendheight) const EXCLUSIVE_LOCKS_REQUIRED(void removeRecursive(const CTransaction &tx, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs)
If sanity-checking is turned on, check makes sure the pool is consistent (does not contain two transa...
void UpdateTransactionsFromBlock(const std::vector< Txid > &vHashesToUpdate) EXCLUSIVE_LOCKS_REQUIRED(cs
UpdateTransactionsFromBlock is called when adding transactions from a disconnected block back to the ...
void AddTransactionsUpdated(unsigned int n)
CTransactionRef get(const Txid &hash) const
size_t DynamicMemoryUsage() const
void removeForReorg(CChain &chain, std::function< bool(txiter)> filter_final_and_mature) EXCLUSIVE_LOCKS_REQUIRED(cs
After reorg, filter the entries that would no longer be valid in the next block, and update the entri...
bool exists(const Txid &txid) const
std::set< txiter, CompareIteratorByHash > setEntries
void removeForBlock(const std::vector< CTransactionRef > &vtx, unsigned int nBlockHeight) EXCLUSIVE_LOCKS_REQUIRED(cs)
indexed_transaction_set::nth_index< 0 >::type::const_iterator txiter
unsigned long size() const
An output of a transaction.
Undo information for a CTransaction.
std::vector< Coin > vprevout
VerifyDBResult VerifyDB(Chainstate &chainstate, const Consensus::Params &consensus_params, CCoinsView &coinsview, int nCheckLevel, int nCheckDepth) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
kernel::Notifications & m_notifications
CVerifyDB(kernel::Notifications ¬ifications)
Chainstate stores and provides an API to update our local knowledge of the current best chain.
void InitCoinsCache(size_t cache_size_bytes) EXCLUSIVE_LOCKS_REQUIRED(bool CanFlushToDisk() const EXCLUSIVE_LOCKS_REQUIRED(
Initialize the in-memory coins cache (to be done after the health of the on-disk database is verified...
Mutex m_chainstate_mutex
The ChainState Mutex A lock that must be held when modifying this ChainState - held in ActivateBestCh...
CChain m_chain
The current chain of blockheaders we consult and build on.
CTxMemPool * GetMempool()
bool RollforwardBlock(const CBlockIndex *pindex, CCoinsViewCache &inputs) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Apply the effects of a block on the utxo cache, ignoring that it may already have been applied.
size_t m_coinstip_cache_size_bytes
The cache size of the in-memory coins view.
void UpdateTip(const CBlockIndex *pindexNew) EXCLUSIVE_LOCKS_REQUIRED(NodeClock::time_poin m_next_write)
Check warning conditions and do some notifications on new chain tip set.
CCoinsViewCache & CoinsTip() EXCLUSIVE_LOCKS_REQUIRED(
bool LoadChainTip() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Update the chain tip based on database information, i.e.
size_t m_coinsdb_cache_size_bytes
The cache size of the on-disk coins view.
bool PreciousBlock(BlockValidationState &state, CBlockIndex *pindex) LOCKS_EXCLUDED(bool InvalidateBlock(BlockValidationState &state, CBlockIndex *pindex) LOCKS_EXCLUDED(void SetBlockFailureFlags(CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(voi ResetBlockFailureFlags)(CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Mark a block as precious and reorganize.
void InvalidBlockFound(CBlockIndex *pindex, const BlockValidationState &state) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
void CheckForkWarningConditions() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
void ForceFlushStateToDisk()
Unconditionally flush all changes to disk.
bool ConnectTip(BlockValidationState &state, CBlockIndex *pindexNew, std::shared_ptr< const CBlock > block_to_connect, ConnectTrace &connectTrace, DisconnectedBlockTransactions &disconnectpool) EXCLUSIVE_LOCKS_REQUIRED(cs_main
Connect a new block to m_chain.
bool LoadGenesisBlock()
Ensures we have a genesis block in the block tree, possibly writing one to disk.
const std::optional< uint256 > m_from_snapshot_blockhash
The blockhash which is the base of the snapshot this chainstate was created from.
bool ActivateBestChain(BlockValidationState &state, std::shared_ptr< const CBlock > pblock=nullptr) LOCKS_EXCLUDED(DisconnectResult DisconnectBlock(const CBlock &block, const CBlockIndex *pindex, CCoinsViewCache &view) EXCLUSIVE_LOCKS_REQUIRED(boo ConnectBlock)(const CBlock &block, BlockValidationState &state, CBlockIndex *pindex, CCoinsViewCache &view, bool fJustCheck=false) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Find the best known block, and make it the tip of the block chain.
CTxMemPool * m_mempool
Optional mempool that is kept in sync with the chain.
CCoinsViewDB & CoinsDB() EXCLUSIVE_LOCKS_REQUIRED(
std::atomic_bool m_prev_script_checks_logged
bool DisconnectTip(BlockValidationState &state, DisconnectedBlockTransactions *disconnectpool) EXCLUSIVE_LOCKS_REQUIRED(cs_main
Disconnect m_chain's tip.
CBlockIndex * FindMostWorkChain() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Return the tip of the chain with the most work in it, that isn't known to be invalid (it's however fa...
ChainstateRole GetRole() const EXCLUSIVE_LOCKS_REQUIRED(void InitCoinsDB(size_t cache_size_bytes, bool in_memory, bool should_wipe, fs::path leveldb_name="chainstate")
Return the current role of the chainstate.
ChainstateManager & m_chainman
The chainstate manager that owns this chainstate.
std::unique_ptr< CoinsViews > m_coins_views
Manages the UTXO set, which is a reflection of the contents of m_chain.
bool ReplayBlocks()
Replay blocks that aren't fully applied to the database.
void PruneBlockIndexCandidates()
Delete all entries in setBlockIndexCandidates that are worse than the current tip.
const CBlockIndex *SnapshotBase() const EXCLUSIVE_LOCKS_REQUIRED(std::set< CBlockIndex *, node::CBlockIndexWorkComparator > setBlockIndexCandidates
The base of the snapshot this chainstate was created from.
void TryAddBlockIndexCandidate(CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
void PruneAndFlush()
Prune blockfiles from the disk if necessary and then flush chainstate changes if we pruned.
bool ResizeCoinsCaches(size_t coinstip_size, size_t coinsdb_size) EXCLUSIVE_LOCKS_REQUIRED(bool FlushStateToDisk(BlockValidationState &state, FlushStateMode mode, int nManualPruneHeight=0)
Resize the CoinsViews caches dynamically and flush state to disk.
node::BlockManager & m_blockman
Reference to a BlockManager instance which itself is shared across all Chainstate instances.
void MaybeUpdateMempoolForReorg(DisconnectedBlockTransactions &disconnectpool, bool fAddToMempool) EXCLUSIVE_LOCKS_REQUIRED(cs_main
Make mempool consistent after a reorg, by re-adding or recursively erasing disconnected block transac...
bool ActivateBestChainStep(BlockValidationState &state, CBlockIndex *pindexMostWork, const std::shared_ptr< const CBlock > &pblock, bool &fInvalidFound, ConnectTrace &connectTrace) EXCLUSIVE_LOCKS_REQUIRED(cs_main
Try to make some progress towards making pindexMostWork the active block.
void ClearBlockIndexCandidates() EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex * FindForkInGlobalIndex(const CBlockLocator &locator) const EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Find the last common block of this chain and a locator.
void InvalidChainFound(CBlockIndex *pindexNew) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Chainstate(CTxMemPool *mempool, node::BlockManager &blockman, ChainstateManager &chainman, std::optional< uint256 > from_snapshot_blockhash=std::nullopt)
bool NeedsRedownload() const EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Whether the chain state needs to be redownloaded due to lack of witness data.
CoinsCacheSizeState GetCoinsCacheSizeState() EXCLUSIVE_LOCKS_REQUIRED(CoinsCacheSizeState GetCoinsCacheSizeState(size_t max_coins_cache_size_bytes, size_t max_mempool_size_bytes) EXCLUSIVE_LOCKS_REQUIRED(std::string ToString() EXCLUSIVE_LOCKS_REQUIRED(RecursiveMutex * MempoolMutex() const LOCK_RETURNED(m_mempool -> cs)
Dictates whether we need to flush the cache to disk or not.
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
util::Result< void > PopulateAndValidateSnapshot(Chainstate &snapshot_chainstate, AutoFile &coins_file, const node::SnapshotMetadata &metadata)
Internal helper for ActivateSnapshot().
const uint256 & AssumedValidBlock() const
SnapshotCompletionResult MaybeCompleteSnapshotValidation() EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex *GetSnapshotBaseBlock() const EXCLUSIVE_LOCKS_REQUIRED(Chainstate ActiveChainstate)() const
Once the background validation chainstate has reached the height which is the base of the UTXO snapsh...
ValidationCache m_validation_cache
double GuessVerificationProgress(const CBlockIndex *pindex) const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Guess verification progress (as a fraction between 0.0=genesis and 1.0=current tip).
size_t m_total_coinstip_cache
The total number of bytes available for us to use across all in-memory coins caches.
std::vector< unsigned char > GenerateCoinbaseCommitment(CBlock &block, const CBlockIndex *pindexPrev) const
Produce the necessary coinbase commitment for a block (modifies the hash, don't call for mined blocks...
MempoolAcceptResult ProcessTransaction(const CTransactionRef &tx, bool test_accept=false) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Try to add a transaction to the memory pool.
kernel::Notifications & GetNotifications() const
bool IsInitialBlockDownload() const
Check whether we are doing an initial block download (synchronizing from disk or network)
void ReceivedBlockTransactions(const CBlock &block, CBlockIndex *pindexNew, const FlatFilePos &pos) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Mark a block as having its data received and checked (up to BLOCK_VALID_TRANSACTIONS).
bool ShouldCheckBlockIndex() const
RecursiveMutex & GetMutex() const LOCK_RETURNED(
Alias for cs_main.
bool IsSnapshotValidated() const EXCLUSIVE_LOCKS_REQUIRED(
Is there a snapshot in use and has it been fully validated?
CBlockIndex * ActiveTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
bool ProcessNewBlock(const std::shared_ptr< const CBlock > &block, bool force_processing, bool min_pow_checked, bool *new_block) LOCKS_EXCLUDED(cs_main)
Process an incoming block.
bool BackgroundSyncInProgress() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
The state of a background sync (for net processing)
size_t m_total_coinsdb_cache
The total number of bytes available for us to use across all leveldb coins databases.
std::atomic< bool > m_cached_finished_ibd
Whether initial block download has ended and IsInitialBlockDownload should return false from now on.
void CheckBlockIndex() const
Make various assertions about the state of the block index.
const util::SignalInterrupt & m_interrupt
void LoadExternalBlockFile(AutoFile &file_in, FlatFilePos *dbp=nullptr, std::multimap< uint256, FlatFilePos > *blocks_with_unknown_parent=nullptr)
Import blocks from an external file.
int ActiveHeight() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
VersionBitsCache m_versionbitscache
Track versionbit status.
bool IsSnapshotActive() const
std::function< void()> snapshot_download_completed
Function to restart active indexes; set dynamically to avoid a circular dependency on base/index....
const CChainParams & GetParams() const
bool ProcessNewBlockHeaders(std::span< const CBlockHeader > headers, bool min_pow_checked, BlockValidationState &state, const CBlockIndex **ppindex=nullptr) LOCKS_EXCLUDED(cs_main)
Process incoming block headers.
const Consensus::Params & GetConsensus() const
ChainstateManager(const util::SignalInterrupt &interrupt, Options options, node::BlockManager::Options blockman_options)
const arith_uint256 & MinimumChainWork() const
util::Result< CBlockIndex * > ActivateSnapshot(AutoFile &coins_file, const node::SnapshotMetadata &metadata, bool in_memory)
Construct and activate a Chainstate on the basis of UTXO snapshot data.
bool LoadBlockIndex() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Load the block tree and coins database from disk, initializing state if we're running with -reindex.
std::optional< uint256 > SnapshotBlockhash() const
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
bool AcceptBlockHeader(const CBlockHeader &block, BlockValidationState &state, CBlockIndex **ppindex, bool min_pow_checked) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
If a block header hasn't already been seen, call CheckBlockHeader on it, ensure that it doesn't desce...
void ReportHeadersPresync(const arith_uint256 &work, int64_t height, int64_t timestamp)
This is used by net_processing to report pre-synchronization progress of headers, as headers are not ...
arith_uint256 nLastPreciousChainwork
chainwork for the last block that preciousblock has been applied to.
bool NotifyHeaderTip() LOCKS_EXCLUDED(GetMutex())
Chainstate &InitializeChainstate(CTxMemPool *mempool) EXCLUSIVE_LOCKS_REQUIRED(std::vector< Chainstate * GetAll)()
Instantiate a new chainstate.
void MaybeRebalanceCaches() EXCLUSIVE_LOCKS_REQUIRED(void UpdateUncommittedBlockStructures(CBlock &block, const CBlockIndex *pindexPrev) const
Check to see if caches are out of balance and if so, call ResizeCoinsCaches() as needed.
bool DetectSnapshotChainstate() EXCLUSIVE_LOCKS_REQUIRED(void ResetChainstates() EXCLUSIVE_LOCKS_REQUIRED(bool DeleteSnapshotChainstate() EXCLUSIVE_LOCKS_REQUIRED(Chainstate &ActivateExistingSnapshot(uint256 base_blockhash) EXCLUSIVE_LOCKS_REQUIRED(bool ValidatedSnapshotCleanup() EXCLUSIVE_LOCKS_REQUIRED(Chainstate &GetChainstateForIndexing() EXCLUSIVE_LOCKS_REQUIRED(std::pair< int, int > GetPruneRange(const Chainstate &chainstate, int last_height_can_prune) EXCLUSIVE_LOCKS_REQUIRED(std::optional< int > GetSnapshotBaseHeight() const EXCLUSIVE_LOCKS_REQUIRED(void RecalculateBestHeader() EXCLUSIVE_LOCKS_REQUIRED(CCheckQueue< CScriptCheck > & GetCheckQueue()
When starting up, search the datadir for a chainstate based on a UTXO snapshot that is in the process...
bool IsUsable(const Chainstate *const cs) const EXCLUSIVE_LOCKS_REQUIRED(
Return true if a chainstate is considered usable.
int32_t nBlockReverseSequenceId
Decreasing counter (used by subsequent preciousblock calls).
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
bool AcceptBlock(const std::shared_ptr< const CBlock > &pblock, BlockValidationState &state, CBlockIndex **ppindex, bool fRequested, const FlatFilePos *dbp, bool *fNewBlock, bool min_pow_checked) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Sufficiently validate a block for disk storage (and store on disk).
CTxOut out
unspent transaction output
bool IsSpent() const
Either this coin never existed (see e.g.
uint32_t nHeight
at which height this containing transaction was included in the active block chain
unsigned int fCoinBase
whether containing transaction was a coinbase
CoinsViews(DBParams db_params, CoinsViewOptions options)
This constructor initializes CCoinsViewDB and CCoinsViewErrorCatcher instances, but it does not creat...
Used to track blocks whose transactions were applied to the UTXO state as a part of a single Activate...
std::vector< PerBlockConnectTrace > & GetBlocksConnected()
std::vector< PerBlockConnectTrace > blocksConnected
void BlockConnected(CBlockIndex *pindex, std::shared_ptr< const CBlock > pblock)
std::pair< uint32_t, size_t > setup_bytes(size_t bytes)
setup_bytes is a convenience function which accounts for internal memory usage when deciding how many...
void insert(Element e)
insert loops at most depth_limit times trying to insert a hash at various locations in the table via ...
bool contains(const Element &e, const bool erase) const
contains iterates through the hash locations for a given element and checks to see if it is present.
DisconnectedBlockTransactions.
std::list< CTransactionRef > take()
Clear all data structures and return the list of transactions.
void removeForBlock(const std::vector< CTransactionRef > &vtx)
Remove any entries that are in this block.
std::vector< CTransactionRef > AddTransactionsFromBlock(const std::vector< CTransactionRef > &vtx)
Add transactions from the block, iterating through vtx in reverse order.
Tp rand_uniform_delay(const Tp &time, typename Tp::duration range) noexcept
Return the time point advanced by a uniform random duration.
Convenience class for initializing and passing the script execution cache and signature cache.
ValidationCache(size_t script_execution_cache_bytes, size_t signature_cache_bytes)
CuckooCache::cache< uint256, SignatureCacheHasher > m_script_execution_cache
CSHA256 ScriptExecutionCacheHasher() const
Return a copy of the pre-initialized hasher.
CSHA256 m_script_execution_cache_hasher
Pre-initialized hasher to avoid having to recreate it for every hash calculation.
SignatureCache m_signature_cache
void BlockDisconnected(const std::shared_ptr< const CBlock > &, const CBlockIndex *pindex)
void BlockChecked(const std::shared_ptr< const CBlock > &, const BlockValidationState &)
void NewPoWValidBlock(const CBlockIndex *, const std::shared_ptr< const CBlock > &)
void UpdatedBlockTip(const CBlockIndex *, const CBlockIndex *, bool fInitialDownload)
void ChainStateFlushed(ChainstateRole, const CBlockLocator &)
void ActiveTipChange(const CBlockIndex &, bool)
void BlockConnected(ChainstateRole, const std::shared_ptr< const CBlock > &, const CBlockIndex *pindex)
std::string GetRejectReason() const
std::string GetDebugMessage() const
bool Error(const std::string &reject_reason)
bool Invalid(Result result, const std::string &reject_reason="", const std::string &debug_message="")
std::string ToString() const
std::vector< std::pair< int, bool > > CheckUnknownActivations(const CBlockIndex *pindex, const CChainParams &chainparams) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Check for unknown activations Returns a vector containing the bit number used for signalling and a bo...
void Clear() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
256-bit unsigned big integer.
constexpr bool IsNull() const
std::string ToString() const
constexpr unsigned char * begin()
A base class defining functions for notifying about certain kernel events.
virtual void headerTip(SynchronizationState state, int64_t height, int64_t timestamp, bool presync)
virtual void fatalError(const bilingual_str &message)
The fatal error notification is sent to notify the user when an error occurs in kernel code that can'...
virtual void warningSet(Warning id, const bilingual_str &message)
virtual void progress(const bilingual_str &title, int progress_percent, bool resume_possible)
virtual InterruptResult blockTip(SynchronizationState state, const CBlockIndex &index, double verification_progress)
virtual void warningUnset(Warning id)
Maintains a tree of blocks (stored in m_block_index) which is consulted to determine where the most-w...
const kernel::BlockManagerOpts m_opts
RecursiveMutex cs_LastBlockFile
bool FlushChainstateBlockFile(int tip_height)
void FindFilesToPrune(std::set< int > &setFilesToPrune, int last_prune, const Chainstate &chain, ChainstateManager &chainman)
Prune block and undo files (blk???.dat and rev???.dat) so that the disk space used is less than a use...
void UpdateBlockInfo(const CBlock &block, unsigned int nHeight, const FlatFilePos &pos)
Update blockfile info while processing a block during reindex.
CBlockIndex * LookupBlockIndex(const uint256 &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
bool ReadBlockUndo(CBlockUndo &blockundo, const CBlockIndex &index) const
std::atomic_bool m_blockfiles_indexed
Whether all blockfiles have been added to the block tree database.
std::vector< CBlockIndex * > GetAllBlockIndices() EXCLUSIVE_LOCKS_REQUIRED(std::multimap< CBlockIndex *, CBlockIndex * > m_blocks_unlinked
All pairs A->B, where A (or one of its ancestors) misses transactions, but B has transactions.
std::set< CBlockIndex * > m_dirty_blockindex
Dirty block index entries.
bool LoadingBlocks() const
void UnlinkPrunedFiles(const std::set< int > &setFilesToPrune) const
Actually unlink the specified files.
bool WriteBlockIndexDB() EXCLUSIVE_LOCKS_REQUIRED(bool LoadBlockIndexDB(const std::optional< uint256 > &snapshot_blockhash) EXCLUSIVE_LOCKS_REQUIRED(void ScanAndUnlinkAlreadyPrunedFiles() EXCLUSIVE_LOCKS_REQUIRED(CBlockIndex * AddToBlockIndex(const CBlockHeader &block, CBlockIndex *&best_header) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Remove any pruned block & undo files that are still on disk.
bool CheckBlockDataAvailability(const CBlockIndex &upper_block LIFETIMEBOUND, const CBlockIndex &lower_block LIFETIMEBOUND) EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex *GetFirstBlock(const CBlockIndex &upper_block LIFETIMEBOUND, uint32_t status_mask, const CBlockIndex *lower_block=nullptr) const EXCLUSIVE_LOCKS_REQUIRED(boo m_have_pruned)
Check if all blocks in the [upper_block, lower_block] range have data available.
bool ReadBlock(CBlock &block, const FlatFilePos &pos, const std::optional< uint256 > &expected_hash) const
Functions for disk access for blocks.
bool m_check_for_pruning
Global flag to indicate we should check to see if there are block/undo files that should be deleted.
bool IsPruneMode() const
Whether running in -prune mode.
void FindFilesToPruneManual(std::set< int > &setFilesToPrune, int nManualPruneHeight, const Chainstate &chain, ChainstateManager &chainman)
bool WriteBlockUndo(const CBlockUndo &blockundo, BlockValidationState &state, CBlockIndex &block) EXCLUSIVE_LOCKS_REQUIRED(FlatFilePos WriteBlock(const CBlock &block, int nHeight)
Store block on disk and update block file statistics.
std::optional< int > m_snapshot_height
The height of the base block of an assumeutxo snapshot, if one is in use.
std::string ToString() const
constexpr const std::byte * begin() const
const uint256 & ToUint256() const LIFETIMEBOUND
std::string GetHex() const
Helper class that manages an interrupt flag, and allows a thread or signal to interrupt another threa...
std::string FormatFullVersion()
const Coin & AccessByTxid(const CCoinsViewCache &view, const Txid &txid)
Utility function to find any unspent output with a given txid.
void AddCoins(CCoinsViewCache &cache, const CTransaction &tx, int nHeight, bool check_for_overwrite)
Utility function to add all of a transaction's outputs to a cache.
uint256 BlockMerkleRoot(const CBlock &block, bool *mutated)
uint256 BlockWitnessMerkleRoot(const CBlock &block, bool *mutated)
static constexpr int NO_WITNESS_COMMITMENT
Index marker for when no witness commitment is present in a coinbase transaction.
static constexpr size_t MINIMUM_WITNESS_COMMITMENT
Minimum size of a witness commitment structure.
static int64_t GetBlockWeight(const CBlock &block)
@ BLOCK_HEADER_LOW_WORK
the block header may be on a too-little-work chain
@ BLOCK_INVALID_HEADER
invalid proof of work or time too old
@ BLOCK_CACHED_INVALID
this block was cached as being invalid and we didn't store the reason why
@ BLOCK_CONSENSUS
invalid by consensus rules (excluding any below reasons)
@ BLOCK_MISSING_PREV
We don't have the previous block the checked one is built on.
@ BLOCK_INVALID_PREV
A block this one builds on is invalid.
@ BLOCK_MUTATED
the block's data didn't match the data committed to by the PoW
@ BLOCK_TIME_FUTURE
block timestamp was > 2 hours in the future (or our clock is bad)
int GetWitnessCommitmentIndex(const CBlock &block)
Compute at which vout of the block's coinbase transaction the witness commitment occurs,...
@ TX_MISSING_INPUTS
transaction was missing some of its inputs
@ TX_MEMPOOL_POLICY
violated mempool's fee/size/descendant/RBF/etc limits
@ TX_PREMATURE_SPEND
transaction spends a coinbase too early, or violates locktime/sequence locks
@ TX_INPUTS_NOT_STANDARD
inputs (covered by txid) failed policy rules
@ TX_WITNESS_STRIPPED
Transaction is missing a witness.
@ TX_CONFLICT
Tx already in mempool or conflicts with a tx in the chain (if it conflicts with another tx in mempool...
@ TX_NOT_STANDARD
otherwise didn't meet our local policy rules
@ TX_WITNESS_MUTATED
Transaction might have a witness prior to SegWit activation, or witness may have been malleated (whic...
@ TX_NO_MEMPOOL
this node does not have a mempool so can't validate the transaction
@ TX_CONSENSUS
invalid by consensus rules
@ TX_RECONSIDERABLE
fails some policy, but might be acceptable if submitted in a (different) package
static constexpr unsigned int LOCKTIME_VERIFY_SEQUENCE
Flags for nSequence and nLockTime locks.
static constexpr int64_t MAX_TIMEWARP
Maximum number of seconds that the timestamp of the first block of a difficulty adjustment period is ...
static const unsigned int MAX_BLOCK_WEIGHT
The maximum allowed weight for a block, see BIP 141 (network rule)
static const unsigned int MAX_BLOCK_SERIALIZED_SIZE
The maximum allowed size for a serialized block, in bytes (only for buffer size limits)
static const int64_t MAX_BLOCK_SIGOPS_COST
The maximum allowed number of signature check operations in a block (network rule)
static const int COINBASE_MATURITY
Coinbase transaction outputs can only be spent after this number of new blocks (network rule)
static const int WITNESS_SCALE_FACTOR
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
bool DestroyDB(const std::string &path_str)
bool DeploymentActiveAfter(const CBlockIndex *pindexPrev, const Consensus::Params ¶ms, Consensus::BuriedDeployment dep, VersionBitsCache &versionbitscache)
Determine if a deployment is active for the next block.
bool DeploymentActiveAt(const CBlockIndex &index, const Consensus::Params ¶ms, Consensus::BuriedDeployment dep, VersionBitsCache &versionbitscache)
Determine if a deployment is active for this block.
static const unsigned int MAX_DISCONNECTED_TX_POOL_BYTES
Maximum bytes for transactions to store for processing during reorg.
bool CheckEphemeralSpends(const Package &package, CFeeRate dust_relay_rate, const CTxMemPool &tx_pool, TxValidationState &out_child_state, Wtxid &out_child_wtxid)
Must be called for each transaction(package) if any dust is in the package.
bool PreCheckEphemeralTx(const CTransaction &tx, CFeeRate dust_relay_rate, CAmount base_fee, CAmount mod_fee, TxValidationState &state)
These utility functions ensure that ephemeral dust is safely created and spent without unduly risking...
static bool exists(const path &p)
static std::string PathToString(const path &path)
Convert path object to a byte string.
bool CheckDiskSpace(const fs::path &dir, uint64_t additional_bytes)
bool VerifyScript(const CScript &scriptSig, const CScript &scriptPubKey, const CScriptWitness *witness, unsigned int flags, const BaseSignatureChecker &checker, ScriptError *serror)
@ SCRIPT_VERIFY_NULLDUMMY
@ SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY
@ SCRIPT_VERIFY_CHECKSEQUENCEVERIFY
ChainstateRole
This enum describes the various roles a specific Chainstate instance can take.
#define LogPrintLevel(category, level,...)
#define LogPrintLevel_(category, level, should_ratelimit,...)
#define LogDebug(category,...)
@ REORG
Removed for reorganization.
std::array< uint8_t, 4 > MessageStartChars
bool CheckTxInputs(const CTransaction &tx, TxValidationState &state, const CCoinsViewCache &inputs, int nSpendHeight, CAmount &txfee)
Check whether all inputs of this transaction are valid (no double spends and amounts) This does not m...
std::function< FILE *(const fs::path &, const char *)> FopenFn
bool IsInterrupted(const T &result)
@ UNKNOWN_NEW_RULES_ACTIVATED
@ LARGE_WORK_INVALID_CHAIN
static bool ComputeUTXOStats(CCoinsView *view, CCoinsStats &stats, T hash_obj, const std::function< void()> &interruption_point)
Calculate statistics about the unspent transaction output set.
const fs::path SNAPSHOT_BLOCKHASH_FILENAME
The file in the snapshot chainstate dir which stores the base blockhash.
bool WriteSnapshotBaseBlockhash(Chainstate &snapshot_chainstate)
bool WriteSnapshotBaseBlockhash(Chainstate &snapshot_chainstate) EXCLUSIVE_LOCKS_REQUIRED(std::optional< uint256 > ReadSnapshotBaseBlockhash(fs::path chaindir) EXCLUSIVE_LOCKS_REQUIRED(constexpr std::string_view SNAPSHOT_CHAINSTATE_SUFFIX
Write out the blockhash of the snapshot base block that was used to construct this chainstate.
std::unordered_map< uint256, CBlockIndex, BlockHasher > BlockMap
std::optional< uint256 > ReadSnapshotBaseBlockhash(fs::path chaindir)
std::optional< fs::path > FindSnapshotChainstateDir(const fs::path &data_dir)
Return a path to the snapshot-based chainstate dir, if one exists.
bilingual_str ErrorString(const Result< T > &result)
std::string ToString(const T &t)
Locale-independent version of std::to_string.
auto Join(const C &container, const S &separator, UnaryOp unary_op)
Join all container items.
static feebumper::Result CheckFeeRate(const CWallet &wallet, const CMutableTransaction &mtx, const CFeeRate &newFeerate, const int64_t maxTxSize, CAmount old_fee, std::vector< bilingual_str > &errors)
Check if the user provided a valid feeRate.
std::shared_ptr< Chain::Notifications > m_notifications
bool IsChildWithParents(const Package &package)
Context-free check that a package is exactly one child and its parents; not all parents need to be pr...
bool IsWellFormedPackage(const Package &txns, PackageValidationState &state, bool require_sorted)
Context-free package policy checks:
uint256 GetPackageHash(const std::vector< CTransactionRef > &transactions)
Get the hash of the concatenated wtxids of transactions, with wtxids treated as a little-endian numbe...
std::vector< CTransactionRef > Package
A package is an ordered list of transactions.
@ PCKG_POLICY
The package itself is invalid (e.g. too many transactions).
@ PCKG_MEMPOOL_ERROR
Mempool logic error.
@ PCKG_TX
At least one tx is invalid.
std::optional< std::string > HasNoNewUnconfirmed(const CTransaction &tx, const CTxMemPool &pool, const CTxMemPool::setEntries &iters_conflicting)
The replacement transaction may only include an unconfirmed input if that input was included in one o...
std::optional< std::pair< DiagramCheckError, std::string > > ImprovesFeerateDiagram(CTxMemPool::ChangeSet &changeset)
The replacement transaction must improve the feerate diagram of the mempool.
std::optional< std::string > PaysForRBF(CAmount original_fees, CAmount replacement_fees, size_t replacement_vsize, CFeeRate relay_fee, const Txid &txid)
The replacement transaction must pay more fees than the original transactions.
std::optional< std::string > PaysMoreThanConflicts(const CTxMemPool::setEntries &iters_conflicting, CFeeRate replacement_feerate, const Txid &txid)
Check that the feerate of the replacement transaction(s) is higher than the feerate of each of the tr...
std::optional< std::string > EntriesAndTxidsDisjoint(const CTxMemPool::setEntries &ancestors, const std::set< Txid > &direct_conflicts, const Txid &txid)
Check the intersection between two sets of transactions (a set of mempool entries and a set of txids)...
std::optional< std::string > GetEntriesForConflicts(const CTransaction &tx, CTxMemPool &pool, const CTxMemPool::setEntries &iters_conflicting, CTxMemPool::setEntries &all_conflicts)
Get all descendants of iters_conflicting.
bool SpendsNonAnchorWitnessProg(const CTransaction &tx, const CCoinsViewCache &prevouts)
Check whether this transaction spends any witness program but P2A, including not-yet-defined ones.
bool AreInputsStandard(const CTransaction &tx, const CCoinsViewCache &mapInputs)
Check transaction inputs.
bool IsWitnessStandard(const CTransaction &tx, const CCoinsViewCache &mapInputs)
Check if the transaction is over standard P2WSH resources limit: 3600bytes witnessScript size,...
bool IsStandardTx(const CTransaction &tx, const std::optional< unsigned > &max_datacarrier_bytes, bool permit_bare_multisig, const CFeeRate &dust_relay_fee, std::string &reason)
Check for standard transaction types.
static constexpr unsigned int EXTRA_DESCENDANT_TX_SIZE_LIMIT
An extra transaction can be added to a package, as long as it only has one ancestor and is no larger ...
static constexpr unsigned int STANDARD_LOCKTIME_VERIFY_FLAGS
Used as the flags parameter to sequence and nLocktime checks in non-consensus code.
static constexpr unsigned int MAX_STANDARD_TX_SIGOPS_COST
The maximum number of sigops we're willing to relay/mine in a single tx.
static constexpr unsigned int MIN_STANDARD_TX_NONWITNESS_SIZE
The minimum non-witness size for transactions we're willing to relay/mine: one larger than 64
static constexpr unsigned int STANDARD_SCRIPT_VERIFY_FLAGS
Standard script verification flags that standard transactions will comply with.
static constexpr unsigned int STANDARD_NOT_MANDATORY_VERIFY_FLAGS
For convenience, standard but not mandatory verify flags.
unsigned int GetNextWorkRequired(const CBlockIndex *pindexLast, const CBlockHeader *pblock, const Consensus::Params ¶ms)
bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params ¶ms)
Check whether a block hash satisfies the proof-of-work requirement specified by nBits.
static constexpr TransactionSerParams TX_NO_WITNESS
static constexpr TransactionSerParams TX_WITH_WITNESS
static CTransactionRef MakeTransactionRef(Tx &&txIn)
std::shared_ptr< const CTransaction > CTransactionRef
uint256 GetRandHash() noexcept
Generate a random uint256.
std::string ScriptErrorString(const ScriptError serror)
enum ScriptError_t ScriptError
@ SCRIPT_ERR_UNKNOWN_ERROR
size_t GetSerializeSize(const T &t)
uint64_t ReadCompactSize(Stream &is, bool range_check=true)
Decode a CompactSize-encoded variable-length integer.
bool CheckSignetBlockSolution(const CBlock &block, const Consensus::Params &consensusParams)
Extract signature and check whether a block has a valid solution.
unsigned char * UCharCast(char *c)
Holds configuration for use during UTXO snapshot load and validation.
AssumeutxoHash hash_serialized
The expected hash of the deserialized UTXO set.
uint64_t m_chain_tx_count
Used to populate the m_chain_tx_count value, which is used during BlockManager::LoadBlockIndex().
Describes a place in the block chain to another node such that if the other node doesn't have the sam...
std::vector< uint256 > vHave
A mutable version of CTransaction.
std::vector< CTxOut > vout
Holds various statistics on transactions within a chain.
User-controlled performance and debug options.
Parameters that influence chain consensus.
bool enforce_BIP94
Enforce BIP94 timewarp attack mitigation.
std::map< uint256, uint32_t > script_flag_exceptions
Hashes of blocks that.
int64_t DifficultyAdjustmentInterval() const
bool signet_blocks
If true, witness commitments contain a payload equal to a Bitcoin Script solution to the signet chall...
int nSubsidyHalvingInterval
int64_t nPowTargetSpacing
std::chrono::seconds PowTargetSpacing() const
Application-specific storage settings.
fs::path path
Location in the filesystem where leveldb data will be stored.
Data structure storing a fee and size, ordered by increasing fee/size.
Validation result for a transaction evaluated by MemPoolAccept (single or package).
const ResultType m_result_type
Result type.
const TxValidationState m_state
Contains information about why the transaction failed.
@ INVALID
Fully validated, valid.
static MempoolAcceptResult Failure(TxValidationState state)
static MempoolAcceptResult FeeFailure(TxValidationState state, CFeeRate effective_feerate, const std::vector< Wtxid > &wtxids_fee_calculations)
static MempoolAcceptResult MempoolTxDifferentWitness(const Wtxid &other_wtxid)
static MempoolAcceptResult MempoolTx(int64_t vsize, CAmount fees)
static MempoolAcceptResult Success(std::list< CTransactionRef > &&replaced_txns, int64_t vsize, CAmount fees, CFeeRate effective_feerate, const std::vector< Wtxid > &wtxids_fee_calculations)
static time_point now() noexcept
Return current system time or mocked time, if set.
static time_point now() noexcept
Return current system time or mocked time, if set.
Validation result for package mempool acceptance.
std::shared_ptr< const CBlock > pblock
PerBlockConnectTrace()=default
void Init(const T &tx, std::vector< CTxOut > &&spent_outputs, bool force=false)
Initialize this PrecomputedTransactionData with transaction data.
bool m_spent_outputs_ready
Whether m_spent_outputs is initialized.
std::vector< CTxOut > m_spent_outputs
const char * what() const noexcept override
An options struct for BlockManager, more ergonomically referred to as BlockManager::Options due to th...
const fs::path blocks_dir
An options struct for ChainstateManager, more ergonomically referred to as ChainstateManager::Options...
ValidationSignals * signals
std::optional< int32_t > check_block_index
std::chrono::seconds max_tip_age
If the tip is older than this, the node is considered to be in initial block download.
const CChainParams & chainparams
CoinsViewOptions coins_view
Options struct containing limit options for a CTxMemPool.
int64_t descendant_count
The maximum allowed number of transactions in a package including the entry and its descendants.
int64_t descendant_size_vbytes
The maximum allowed size in virtual bytes of an entry and its descendants within a package.
int64_t ancestor_count
The maximum allowed number of transactions in a package including the entry and its ancestors.
int64_t ancestor_size_vbytes
The maximum allowed size in virtual bytes of an entry and its ancestors within a package.
#define AssertLockNotHeld(cs)
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
#define EXCLUSIVE_LOCKS_REQUIRED(...)
#define LOCKS_EXCLUDED(...)
#define LOG_TIME_MILLIS_WITH_CATEGORY(end_msg, log_category)
#define LOG_TIME_MILLIS_WITH_CATEGORY_MSG_ONCE(end_msg, log_category)
#define TRACEPOINT(context,...)
consteval auto _(util::TranslatedLiteral str)
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.
std::optional< std::string > PackageTRUCChecks(const CTransactionRef &ptx, int64_t vsize, const Package &package, const CTxMemPool::setEntries &mempool_ancestors)
Must be called for every transaction that is submitted within a package, even if not TRUC.
std::optional< std::pair< std::string, CTransactionRef > > SingleTRUCChecks(const CTransactionRef &ptx, const CTxMemPool::setEntries &mempool_ancestors, const std::set< Txid > &direct_conflicts, int64_t vsize)
Must be called for every transaction, even if not TRUC.
static constexpr decltype(CTransaction::version) TRUC_VERSION
bool CheckTransaction(const CTransaction &tx, TxValidationState &state)
bool EvaluateSequenceLocks(const CBlockIndex &block, std::pair< int, int64_t > lockPair)
std::pair< int, int64_t > CalculateSequenceLocks(const CTransaction &tx, int flags, std::vector< int > &prevHeights, const CBlockIndex &block)
Calculates the block height and previous block's median time past at which the transaction will be co...
int64_t GetTransactionSigOpCost(const CTransaction &tx, const CCoinsViewCache &inputs, uint32_t flags)
Compute total signature operation cost of a transaction.
unsigned int GetLegacySigOpCount(const CTransaction &tx)
Auxiliary functions for transaction validation (ideally should not be exposed)
bool SequenceLocks(const CTransaction &tx, int flags, std::vector< int > &prevHeights, const CBlockIndex &block)
Check if transaction is final per BIP 68 sequence numbers and can be included in a block.
bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64_t nBlockTime)
Check if transaction is final and can be included in a block with the specified height and time.
bool TestLockPointValidity(CChain &active_chain, const LockPoints &lp)
Test whether the LockPoints height and time are still valid on the current chain.
static const uint32_t MEMPOOL_HEIGHT
Fake height value used in Coin to signify they are only in the memory pool (since 0....
int64_t GetTime()
DEPRECATED Use either ClockType::now() or Now<TimePointType>() if a cast is needed.
std::string FormatISO8601DateTime(int64_t nTime)
ISO 8601 formatting is preferred.
constexpr int64_t count_seconds(std::chrono::seconds t)
std::chrono::time_point< NodeClock, std::chrono::seconds > NodeSeconds
PackageMempoolAcceptResult ProcessNewPackage(Chainstate &active_chainstate, CTxMemPool &pool, const Package &package, bool test_accept, const std::optional< CFeeRate > &client_maxfeerate)
Validate (and maybe submit) a package to the mempool.
bool CheckInputScripts(const CTransaction &tx, TxValidationState &state, const CCoinsViewCache &inputs, unsigned int flags, bool cacheSigStore, bool cacheFullScriptStore, PrecomputedTransactionData &txdata, ValidationCache &validation_cache, std::vector< CScriptCheck > *pvChecks=nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Check whether all of this transaction's input scripts succeed.
static void LimitMempoolSize(CTxMemPool &pool, CCoinsViewCache &coins_cache) EXCLUSIVE_LOCKS_REQUIRED(
bool IsBlockMutated(const CBlock &block, bool check_witness_root)
Check if a block has been mutated (with respect to its merkle root and witness commitments).
static unsigned int GetBlockScriptFlags(const CBlockIndex &block_index, const ChainstateManager &chainman)
std::optional< LockPoints > CalculateLockPointsAtTip(CBlockIndex *tip, const CCoinsView &coins_view, const CTransaction &tx)
static constexpr size_t WARN_FLUSH_COINS_SIZE
Size threshold for warning about slow UTXO set flush to disk.
bool CheckFinalTxAtTip(const CBlockIndex &active_chain_tip, const CTransaction &tx)
CAmount GetBlockSubsidy(int nHeight, const Consensus::Params &consensusParams)
MempoolAcceptResult AcceptToMemoryPool(Chainstate &active_chainstate, const CTransactionRef &tx, int64_t accept_time, bool bypass_limits, bool test_accept)
Try to add a transaction to the mempool.
int ApplyTxInUndo(Coin &&undo, CCoinsViewCache &view, const COutPoint &out)
Restore the UTXO in a Coin at a given COutPoint.
static bool ContextualCheckBlock(const CBlock &block, BlockValidationState &state, const ChainstateManager &chainman, const CBlockIndex *pindexPrev)
NOTE: This function is not currently invoked by ConnectBlock(), so we should consider upgrade issues ...
bool FatalError(Notifications ¬ifications, BlockValidationState &state, const bilingual_str &message)
bool CheckSequenceLocksAtTip(CBlockIndex *tip, const LockPoints &lock_points)
Check if transaction will be BIP68 final in the next block to be created on top of tip.
static bool CheckInputsFromMempoolAndCache(const CTransaction &tx, TxValidationState &state, const CCoinsViewCache &view, const CTxMemPool &pool, unsigned int flags, PrecomputedTransactionData &txdata, CCoinsViewCache &coins_tip, ValidationCache &validation_cache) EXCLUSIVE_LOCKS_REQUIRED(cs_main
Checks to avoid mempool polluting consensus critical paths since cached signature and script validity...
static void UpdateTipLog(const ChainstateManager &chainman, const CCoinsViewCache &coins_tip, const CBlockIndex *tip, const std::string &func_name, const std::string &prefix, const std::string &warning_messages) EXCLUSIVE_LOCKS_REQUIRED(
bool HasValidProofOfWork(const std::vector< CBlockHeader > &headers, const Consensus::Params &consensusParams)
Check with the proof of work on each blockheader matches the value in nBits.
static ChainstateManager::Options && Flatten(ChainstateManager::Options &&opts)
Apply default chain params to nullopt members.
static constexpr auto DATABASE_WRITE_INTERVAL_MAX
static bool CheckWitnessMalleation(const CBlock &block, bool expect_witness_commitment, BlockValidationState &state)
CheckWitnessMalleation performs checks for block malleation with regard to its witnesses.
void UpdateCoins(const CTransaction &tx, CCoinsViewCache &inputs, CTxUndo &txundo, int nHeight)
static bool DeleteCoinsDBFromDisk(const fs::path db_path, bool is_snapshot) EXCLUSIVE_LOCKS_REQUIRED(
static bool CheckMerkleRoot(const CBlock &block, BlockValidationState &state)
static constexpr int PRUNE_LOCK_BUFFER
The number of blocks to keep below the deepest prune lock.
arith_uint256 CalculateClaimedHeadersWork(std::span< const CBlockHeader > headers)
Return the sum of the claimed work on a given set of headers.
const std::vector< std::string > CHECKLEVEL_DOC
Documentation for argument 'checklevel'.
bool CheckBlock(const CBlock &block, BlockValidationState &state, const Consensus::Params &consensusParams, bool fCheckPOW, bool fCheckMerkleRoot)
Functions for validating blocks and updating the block tree.
static constexpr std::chrono::hours MAX_FEE_ESTIMATION_TIP_AGE
Maximum age of our tip for us to be considered current for fee estimation.
void PruneBlockFilesManual(Chainstate &active_chainstate, int nManualPruneHeight)
Prune block files up to a given height.
static void FlushSnapshotToDisk(CCoinsViewCache &coins_cache, bool snapshot_loaded)
static bool IsCurrentForFeeEstimation(Chainstate &active_chainstate) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
static constexpr auto DATABASE_WRITE_INTERVAL_MIN
Time window to wait between writing blocks/block index and chainstate to disk.
BlockValidationState TestBlockValidity(Chainstate &chainstate, const CBlock &block, const bool check_pow, const bool check_merkle_root)
Verify a block, including transactions.
static bool CheckBlockHeader(const CBlockHeader &block, BlockValidationState &state, const Consensus::Params &consensusParams, bool fCheckPOW=true)
bool IsBIP30Repeat(const CBlockIndex &block_index)
Identifies blocks that overwrote an existing coinbase output in the UTXO set (see BIP30)
static void SnapshotUTXOHashBreakpoint(const util::SignalInterrupt &interrupt)
static fs::path GetSnapshotCoinsDBPath(Chainstate &cs) EXCLUSIVE_LOCKS_REQUIRED(
static SynchronizationState GetSynchronizationState(bool init, bool blockfiles_indexed)
static bool ContextualCheckBlockHeader(const CBlockHeader &block, BlockValidationState &state, BlockManager &blockman, const ChainstateManager &chainman, const CBlockIndex *pindexPrev) EXCLUSIVE_LOCKS_REQUIRED(
Context-dependent validity checks.
bool IsBIP30Unspendable(const uint256 &block_hash, int block_height)
Identifies blocks which coinbase output was subsequently overwritten in the UTXO set (see BIP30)
TRACEPOINT_SEMAPHORE(validation, block_connected)
static void LimitValidationInterfaceQueue(ValidationSignals &signals) LOCKS_EXCLUDED(cs_main)
static constexpr int MAX_SCRIPTCHECK_THREADS
Maximum number of dedicated script-checking threads allowed.
static const unsigned int MIN_BLOCKS_TO_KEEP
Block files containing a block-height within MIN_BLOCKS_TO_KEEP of ActiveChain().Tip() will not be pr...
@ BASE_BLOCKHASH_MISMATCH
SynchronizationState
Current sync state passed to tip changed callbacks.
constexpr std::array FlushStateModeNames
constexpr int64_t LargeCoinsCacheThreshold(int64_t total_space) noexcept
@ LARGE
The cache is at >= 90% capacity.
@ CRITICAL
The coins cache is in immediate need of a flush.