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 (
const auto err{
SingleTRUCChecks(ws.m_ptx, ws.m_ancestors, ws.m_conflicts, ws.m_vsize)}) {
1049 if (
args.m_allow_sibling_eviction && err->second !=
nullptr) {
1055 ws.m_conflicts.insert(err->second->GetHash());
1059 ws.m_iters_conflicting.insert(m_pool.GetIter(err->second->GetHash()).value());
1060 ws.m_sibling_eviction =
true;
1081 m_subpackage.m_rbf |= !ws.m_conflicts.empty();
1085bool MemPoolAccept::ReplacementChecks(Workspace& ws)
1091 const Txid& hash = ws.m_hash;
1094 CFeeRate newFeeRate(ws.m_modified_fees, ws.m_vsize);
1108 strprintf(
"insufficient fee%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1116 strprintf(
"too many potential replacements%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1121 Assume(!ws.m_sibling_eviction);
1123 strprintf(
"replacement-adds-unconfirmed%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1129 m_subpackage.m_conflicting_fees += it->GetModifiedFee();
1130 m_subpackage.m_conflicting_size += it->GetTxSize();
1132 if (
const auto err_string{
PaysForRBF(m_subpackage.m_conflicting_fees, ws.m_modified_fees, ws.m_vsize,
1133 m_pool.m_opts.incremental_relay_feerate, hash)}) {
1136 strprintf(
"insufficient fee%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1140 for (
auto it : all_conflicts) {
1141 m_subpackage.m_changeset->StageRemoval(it);
1146bool MemPoolAccept::PackageMempoolChecks(
const std::vector<CTransactionRef>& txns,
1147 std::vector<Workspace>& workspaces,
1148 const int64_t total_vsize,
1155 assert(std::all_of(txns.cbegin(), txns.cend(), [
this](
const auto& tx) { return !m_pool.exists(tx->GetHash()); }));
1157 assert(txns.size() == workspaces.size());
1159 auto result = m_pool.CheckPackageLimits(txns, total_vsize);
1166 if (!m_subpackage.m_rbf)
return true;
1177 for (
const auto& ws : workspaces) {
1178 if (!ws.m_ancestors.empty()) {
1185 for (Workspace& ws : workspaces) {
1187 direct_conflict_iters.merge(ws.m_iters_conflicting);
1190 const auto& parent_ws = workspaces[0];
1191 const auto& child_ws = workspaces[1];
1199 "package RBF failed: too many potential replacements", *err_string);
1204 m_subpackage.m_changeset->StageRemoval(it);
1205 m_subpackage.m_conflicting_fees += it->GetModifiedFee();
1206 m_subpackage.m_conflicting_size += it->GetTxSize();
1210 const Txid& child_hash = child_ws.m_ptx->GetHash();
1211 if (
const auto err_string{
PaysForRBF(m_subpackage.m_conflicting_fees,
1212 m_subpackage.m_total_modified_fees,
1213 m_subpackage.m_total_vsize,
1214 m_pool.m_opts.incremental_relay_feerate, child_hash)}) {
1216 "package RBF failed: insufficient anti-DoS fees", *err_string);
1221 const CFeeRate parent_feerate(parent_ws.m_modified_fees, parent_ws.m_vsize);
1222 const CFeeRate package_feerate(m_subpackage.m_total_modified_fees, m_subpackage.m_total_vsize);
1223 if (package_feerate <= parent_feerate) {
1225 "package RBF failed: package feerate is less than or equal to parent feerate",
1226 strprintf(
"package feerate %s <= parent feerate is %s", package_feerate.ToString(), parent_feerate.ToString()));
1233 "package RBF failed: " + err_tup.value().second,
"");
1236 LogDebug(
BCLog::TXPACKAGES,
"package RBF checks passed: parent %s (wtxid=%s), child %s (wtxid=%s), package hash (%s)\n",
1237 txns.front()->GetHash().ToString(), txns.front()->GetWitnessHash().ToString(),
1238 txns.back()->GetHash().ToString(), txns.back()->GetWitnessHash().ToString(),
1245bool MemPoolAccept::PolicyScriptChecks(
const ATMPArgs&
args, Workspace& ws)
1256 if (!
CheckInputScripts(tx, state, m_view, scriptVerifyFlags,
true,
false, ws.m_precomputed_txdata, GetValidationCache())) {
1268bool MemPoolAccept::ConsensusScriptChecks(
const ATMPArgs&
args, Workspace& ws)
1273 const Txid& hash = ws.m_hash;
1291 unsigned int currentBlockScriptVerifyFlags{
GetBlockScriptFlags(*m_active_chainstate.m_chain.Tip(), m_active_chainstate.m_chainman)};
1293 ws.m_precomputed_txdata, m_active_chainstate.CoinsTip(), GetValidationCache())) {
1294 LogPrintf(
"BUG! PLEASE REPORT THIS! CheckInputScripts failed against latest-block but not STANDARD flags %s, %s\n", hash.
ToString(), state.
ToString());
1301void MemPoolAccept::FinalizeSubpackage(
const ATMPArgs&
args)
1306 if (!m_subpackage.m_changeset->GetRemovals().empty())
Assume(
args.m_allow_replacement);
1310 std::string log_string =
strprintf(
"replacing mempool tx %s (wtxid=%s, fees=%s, vsize=%s). ",
1311 it->GetTx().GetHash().ToString(),
1312 it->GetTx().GetWitnessHash().ToString(),
1315 FeeFrac feerate{m_subpackage.m_total_modified_fees, int32_t(m_subpackage.m_total_vsize)};
1317 const bool replaced_with_tx{m_subpackage.m_changeset->GetTxCount() == 1};
1318 if (replaced_with_tx) {
1319 const CTransaction& tx = m_subpackage.m_changeset->GetAddedTxn(0);
1321 log_string +=
strprintf(
"New tx %s (wtxid=%s, fees=%s, vsize=%s)",
1327 tx_or_package_hash =
GetPackageHash(m_subpackage.m_changeset->GetAddedTxns());
1328 log_string +=
strprintf(
"New package %s with %lu txs, fees=%s, vsize=%s",
1329 tx_or_package_hash.ToString(),
1330 m_subpackage.m_changeset->GetTxCount(),
1337 it->GetTx().GetHash().data(),
1340 std::chrono::duration_cast<std::chrono::duration<std::uint64_t>>(it->GetTime()).count(),
1341 tx_or_package_hash.data(),
1346 m_subpackage.m_replaced_transactions.push_back(it->GetSharedTx());
1348 m_subpackage.m_changeset->Apply();
1349 m_subpackage.m_changeset.reset();
1352bool MemPoolAccept::SubmitPackage(
const ATMPArgs&
args, std::vector<Workspace>& workspaces,
1354 std::map<Wtxid, MempoolAcceptResult>& results)
1360 assert(std::all_of(workspaces.cbegin(), workspaces.cend(), [
this](
const auto& ws) { return !m_pool.exists(ws.m_ptx->GetHash()); }));
1362 bool all_submitted =
true;
1363 FinalizeSubpackage(
args);
1368 for (Workspace& ws : workspaces) {
1369 if (!ConsensusScriptChecks(
args, ws)) {
1373 all_submitted =
false;
1375 strprintf(
"BUG! PolicyScriptChecks succeeded but ConsensusScriptChecks failed: %s",
1376 ws.m_ptx->GetHash().ToString()));
1378 if (!m_subpackage.m_changeset) m_subpackage.m_changeset = m_pool.GetChangeSet();
1379 m_subpackage.m_changeset->StageRemoval(m_pool.GetIter(ws.m_ptx->GetHash()).value());
1382 if (!all_submitted) {
1383 Assume(m_subpackage.m_changeset);
1387 m_subpackage.m_changeset->Apply();
1388 m_subpackage.m_changeset.reset();
1392 std::vector<Wtxid> all_package_wtxids;
1393 all_package_wtxids.reserve(workspaces.size());
1394 std::transform(workspaces.cbegin(), workspaces.cend(), std::back_inserter(all_package_wtxids),
1395 [](
const auto& ws) { return ws.m_ptx->GetWitnessHash(); });
1397 if (!m_subpackage.m_replaced_transactions.empty()) {
1398 LogDebug(
BCLog::MEMPOOL,
"replaced %u mempool transactions with %u new one(s) for %s additional fees, %d delta bytes\n",
1399 m_subpackage.m_replaced_transactions.size(), workspaces.size(),
1400 m_subpackage.m_total_modified_fees - m_subpackage.m_conflicting_fees,
1401 m_subpackage.m_total_vsize -
static_cast<int>(m_subpackage.m_conflicting_size));
1405 for (Workspace& ws : workspaces) {
1406 auto iter = m_pool.GetIter(ws.m_ptx->GetHash());
1407 Assume(iter.has_value());
1408 const auto effective_feerate =
args.m_package_feerates ? ws.m_package_feerate :
1409 CFeeRate{ws.m_modified_fees,
static_cast<int32_t
>(ws.m_vsize)};
1410 const auto effective_feerate_wtxids =
args.m_package_feerates ? all_package_wtxids :
1411 std::vector<Wtxid>{ws.m_ptx->GetWitnessHash()};
1412 results.emplace(ws.m_ptx->GetWitnessHash(),
1414 ws.m_base_fees, effective_feerate, effective_feerate_wtxids));
1415 if (!m_pool.m_opts.signals)
continue;
1418 ws.m_vsize, (*iter)->GetHeight(),
1419 args.m_bypass_limits,
args.m_package_submission,
1421 m_pool.HasNoInputsOf(tx));
1422 m_pool.m_opts.signals->TransactionAddedToMempool(tx_info, m_pool.GetAndIncrementSequence());
1424 return all_submitted;
1433 const std::vector<Wtxid> single_wtxid{ws.m_ptx->GetWitnessHash()};
1435 if (!PreChecks(
args, ws)) {
1443 m_subpackage.m_total_vsize = ws.m_vsize;
1444 m_subpackage.m_total_modified_fees = ws.m_modified_fees;
1447 if (
args.m_client_maxfeerate &&
CFeeRate(ws.m_modified_fees, ws.m_vsize) >
args.m_client_maxfeerate.value()) {
1452 if (m_pool.m_opts.require_standard) {
1454 if (!
CheckEphemeralSpends({ptx}, m_pool.m_opts.dust_relay_feerate, m_pool, ws.m_state, dummy_wtxid)) {
1459 if (m_subpackage.m_rbf && !ReplacementChecks(ws)) {
1473 const CFeeRate effective_feerate{ws.m_modified_fees,
static_cast<int32_t
>(ws.m_vsize)};
1475 if (
args.m_test_accept) {
1477 ws.m_base_fees, effective_feerate, single_wtxid);
1480 FinalizeSubpackage(
args);
1483 if (!
args.m_package_submission && !
args.m_bypass_limits) {
1487 CleanupTemporaryCoins();
1489 if (!m_pool.exists(ws.m_hash)) {
1496 if (m_pool.m_opts.signals) {
1498 auto iter = m_pool.GetIter(tx.
GetHash());
1499 Assume(iter.has_value());
1501 ws.m_vsize, (*iter)->GetHeight(),
1502 args.m_bypass_limits,
args.m_package_submission,
1504 m_pool.HasNoInputsOf(tx));
1505 m_pool.m_opts.signals->TransactionAddedToMempool(tx_info, m_pool.GetAndIncrementSequence());
1508 if (!m_subpackage.m_replaced_transactions.empty()) {
1509 LogDebug(
BCLog::MEMPOOL,
"replaced %u mempool transactions with 1 new transaction for %s additional fees, %d delta bytes\n",
1510 m_subpackage.m_replaced_transactions.size(),
1511 ws.m_modified_fees - m_subpackage.m_conflicting_fees,
1512 ws.m_vsize -
static_cast<int>(m_subpackage.m_conflicting_size));
1516 effective_feerate, single_wtxid);
1527 std::vector<Workspace> workspaces{};
1528 workspaces.reserve(txns.size());
1529 std::transform(txns.cbegin(), txns.cend(), std::back_inserter(workspaces),
1530 [](
const auto& tx) { return Workspace(tx); });
1531 std::map<Wtxid, MempoolAcceptResult> results;
1536 for (Workspace& ws : workspaces) {
1537 if (!PreChecks(
args, ws)) {
1546 if (
args.m_client_maxfeerate &&
CFeeRate(ws.m_modified_fees, ws.m_vsize) >
args.m_client_maxfeerate.value()) {
1564 m_viewmempool.PackageAddTransaction(ws.m_ptx);
1569 for (Workspace& ws : workspaces) {
1585 m_subpackage.m_total_vsize = std::accumulate(workspaces.cbegin(), workspaces.cend(), int64_t{0},
1586 [](int64_t
sum,
auto& ws) { return sum + ws.m_vsize; });
1587 m_subpackage.m_total_modified_fees = std::accumulate(workspaces.cbegin(), workspaces.cend(),
CAmount{0},
1588 [](
CAmount sum,
auto& ws) { return sum + ws.m_modified_fees; });
1589 const CFeeRate package_feerate(m_subpackage.m_total_modified_fees, m_subpackage.m_total_vsize);
1590 std::vector<Wtxid> all_package_wtxids;
1591 all_package_wtxids.reserve(workspaces.size());
1592 std::transform(workspaces.cbegin(), workspaces.cend(), std::back_inserter(all_package_wtxids),
1593 [](
const auto& ws) { return ws.m_ptx->GetWitnessHash(); });
1595 if (
args.m_package_feerates &&
1596 !
CheckFeeRate(m_subpackage.m_total_vsize, m_subpackage.m_total_modified_fees, placeholder_state)) {
1604 if (txns.size() > 1 && !PackageMempoolChecks(txns, workspaces, m_subpackage.m_total_vsize, package_state)) {
1609 if (m_pool.m_opts.require_standard) {
1612 if (!
CheckEphemeralSpends(txns, m_pool.m_opts.dust_relay_feerate, m_pool, child_state, child_wtxid)) {
1619 for (Workspace& ws : workspaces) {
1620 ws.m_package_feerate = package_feerate;
1621 if (!PolicyScriptChecks(
args, ws)) {
1627 if (
args.m_test_accept) {
1628 const auto effective_feerate =
args.m_package_feerates ? ws.m_package_feerate :
1629 CFeeRate{ws.m_modified_fees,
static_cast<int32_t
>(ws.m_vsize)};
1630 const auto effective_feerate_wtxids =
args.m_package_feerates ? all_package_wtxids :
1631 std::vector<Wtxid>{ws.m_ptx->GetWitnessHash()};
1632 results.emplace(ws.m_ptx->GetWitnessHash(),
1634 ws.m_vsize, ws.m_base_fees, effective_feerate,
1635 effective_feerate_wtxids));
1641 if (!SubmitPackage(
args, workspaces, package_state, results)) {
1649void MemPoolAccept::CleanupTemporaryCoins()
1670 for (
const auto& outpoint : m_viewmempool.GetNonBaseCoins()) {
1673 m_view.Uncache(outpoint);
1676 m_viewmempool.Reset();
1684 if (subpackage.size() > 1) {
1685 return AcceptMultipleTransactions(subpackage,
args);
1687 const auto& tx = subpackage.front();
1688 ATMPArgs single_args = ATMPArgs::SingleInPackageAccept(
args);
1689 const auto single_res = AcceptSingleTransaction(tx, single_args);
1700 ClearSubPackageState();
1707 Assert(!package.empty());
1733 std::map<Wtxid, MempoolAcceptResult> results_final;
1737 std::map<Wtxid, MempoolAcceptResult> individual_results_nonfinal;
1739 bool quit_early{
false};
1740 std::vector<CTransactionRef> txns_package_eval;
1741 for (
const auto& tx : package) {
1743 const auto& txid = tx->
GetHash();
1747 if (m_pool.exists(wtxid)) {
1757 const auto& entry{*
Assert(m_pool.GetEntry(txid))};
1759 }
else if (m_pool.exists(txid)) {
1767 const auto& entry{*
Assert(m_pool.GetEntry(txid))};
1773 const auto single_package_res = AcceptSubPackage({tx},
args);
1774 const auto& single_res = single_package_res.m_tx_results.at(wtxid);
1778 assert(m_pool.exists(wtxid));
1779 results_final.emplace(wtxid, single_res);
1780 }
else if (package.size() == 1 ||
1794 individual_results_nonfinal.emplace(wtxid, single_res);
1796 individual_results_nonfinal.emplace(wtxid, single_res);
1797 txns_package_eval.push_back(tx);
1802 auto multi_submission_result = quit_early || txns_package_eval.empty() ?
PackageMempoolAcceptResult(package_state_quit_early, {}) :
1803 AcceptSubPackage(txns_package_eval,
args);
1809 ClearSubPackageState();
1816 for (
const auto& tx : package) {
1818 if (multi_submission_result.m_tx_results.count(wtxid) > 0) {
1820 Assume(results_final.count(wtxid) == 0);
1823 const auto& txresult = multi_submission_result.m_tx_results.at(wtxid);
1830 results_final.emplace(wtxid, txresult);
1832 }
else if (
const auto it{results_final.find(wtxid)}; it != results_final.end()) {
1836 Assume(individual_results_nonfinal.count(wtxid) == 0);
1838 if (!m_pool.exists(tx->
GetHash())) {
1843 results_final.erase(wtxid);
1846 }
else if (
const auto it{individual_results_nonfinal.find(wtxid)}; it != individual_results_nonfinal.end()) {
1849 results_final.emplace(wtxid, it->second);
1852 Assume(results_final.size() == package.size());
1859 int64_t accept_time,
bool bypass_limits,
bool test_accept)
1866 std::vector<COutPoint> coins_to_uncache;
1867 auto args = MemPoolAccept::ATMPArgs::SingleAccept(chainparams, accept_time, bypass_limits, coins_to_uncache, test_accept);
1875 for (
const COutPoint& hashTx : coins_to_uncache)
1878 tx->GetHash().data(),
1889 const Package& package,
bool test_accept,
const std::optional<CFeeRate>& client_maxfeerate)
1892 assert(!package.empty());
1893 assert(std::all_of(package.cbegin(), package.cend(), [](
const auto& tx){return tx != nullptr;}));
1895 std::vector<COutPoint> coins_to_uncache;
1900 auto args = MemPoolAccept::ATMPArgs::PackageTestAccept(chainparams,
GetTime(), coins_to_uncache);
1901 return MemPoolAccept(pool, active_chainstate).AcceptMultipleTransactions(package,
args);
1903 auto args = MemPoolAccept::ATMPArgs::PackageChildWithParents(chainparams,
GetTime(), coins_to_uncache, client_maxfeerate);
1904 return MemPoolAccept(pool, active_chainstate).AcceptPackage(package,
args);
1909 if (test_accept || result.m_state.IsInvalid()) {
1910 for (
const COutPoint& hashTx : coins_to_uncache) {
1929 nSubsidy >>= halvings;
1934 : m_dbview{
std::move(db_params),
std::move(options)},
1935 m_catcherview(&m_dbview) {}
1937void CoinsViews::InitCache()
1940 m_cacheview = std::make_unique<CCoinsViewCache>(&m_catcherview);
1947 std::optional<uint256> from_snapshot_blockhash)
1948 : m_mempool(mempool),
1949 m_blockman(blockman),
1950 m_chainman(chainman),
1951 m_from_snapshot_blockhash(from_snapshot_blockhash) {}
1953const CBlockIndex* Chainstate::SnapshotBase()
const
1957 return m_cached_snapshot_base;
1961 size_t cache_size_bytes,
1964 fs::path leveldb_name)
1973 .cache_bytes = cache_size_bytes,
1974 .memory_only = in_memory,
1975 .wipe_data = should_wipe,
1983void Chainstate::InitCoinsCache(
size_t cache_size_bytes)
2009 if (chain.Tip() ==
nullptr) {
2018 LogInfo(
"Leaving InitialBlockDownload (latching to false)");
2035 LogPrintf(
"%s: Warning: Found invalid chain at least ~6 blocks longer than our best chain.\nChain state database corruption likely.\n", __func__);
2038 _(
"Warning: We do not appear to fully agree with our peers! You may need to upgrade, or other nodes may need to upgrade."));
2051 SetBlockFailureFlags(pindexNew);
2056 LogPrintf(
"%s: invalid block=%s height=%d log2_work=%f date=%s\n", __func__,
2061 LogPrintf(
"%s: current best=%s height=%d log2_work=%f date=%s\n", __func__,
2099 if (
VerifyScript(scriptSig,
m_tx_out.
scriptPubKey, witness,
nFlags,
CachingTransactionSignatureChecker(
ptxTo,
nIn,
m_tx_out.
nValue,
cacheStore, *
m_signature_cache, *
txdata), &error)) {
2100 return std::nullopt;
2103 return std::make_pair(error, std::move(debug_str));
2108 : m_signature_cache{signature_cache_bytes}
2119 LogInfo(
"Using %zu MiB out of %zu MiB requested for script execution cache, able to store %zu elements",
2120 approx_size_bytes >> 20, script_execution_cache_bytes >> 20, num_elems);
2146 std::vector<CScriptCheck>* pvChecks)
2151 pvChecks->reserve(tx.
vin.size());
2168 std::vector<CTxOut> spent_outputs;
2169 spent_outputs.reserve(tx.
vin.size());
2171 for (
const auto& txin : tx.
vin) {
2175 spent_outputs.emplace_back(coin.
out);
2177 txdata.
Init(tx, std::move(spent_outputs));
2181 for (
unsigned int i = 0; i < tx.
vin.size(); i++) {
2192 pvChecks->emplace_back(std::move(check));
2193 }
else if (
auto result = check(); result.has_value()) {
2208 if (cacheFullScriptStore && !pvChecks) {
2236 if (undo.nHeight == 0) {
2242 undo.nHeight = alternate.
nHeight;
2267 LogError(
"DisconnectBlock(): failure reading undo data\n");
2271 if (blockUndo.
vtxundo.size() + 1 != block.
vtx.size()) {
2272 LogError(
"DisconnectBlock(): block and undo data inconsistent\n");
2282 bool fEnforceBIP30 = !((pindex->
nHeight==91722 && pindex->
GetBlockHash() ==
uint256{
"00000000000271a2dc26e7667f8419f2e15416dc6955e5a6c6cdf3f2574dd08e"}) ||
2283 (pindex->
nHeight==91812 && pindex->
GetBlockHash() ==
uint256{
"00000000000af0aed4792b1acee3d966af36cf5def14935db8de83d6f9306f2f"}));
2286 for (
int i = block.
vtx.size() - 1; i >= 0; i--) {
2290 bool is_bip30_exception = (is_coinbase && !fEnforceBIP30);
2294 for (
size_t o = 0; o < tx.
vout.size(); o++) {
2295 if (!tx.
vout[o].scriptPubKey.IsUnspendable()) {
2300 if (!is_bip30_exception) {
2311 LogError(
"DisconnectBlock(): transaction and undo data inconsistent\n");
2314 for (
unsigned int j = tx.
vin.size(); j > 0;) {
2385 const auto time_start{SteadyClock::now()};
2401 if (!
CheckBlock(block, state, params.GetConsensus(), !fJustCheck, !fJustCheck)) {
2413 uint256 hashPrevBlock = pindex->
pprev ==
nullptr ?
uint256() : pindex->pprev->GetBlockHash();
2420 if (block_hash == params.GetConsensus().hashGenesisBlock) {
2426 bool fScriptChecks =
true;
2435 if (it->second.GetAncestor(pindex->
nHeight) == pindex &&
2457 const auto time_1{SteadyClock::now()};
2458 m_chainman.time_check += time_1 - time_start;
2460 Ticks<MillisecondsDouble>(time_1 - time_start),
2502 static constexpr int BIP34_IMPLIES_BIP30_LIMIT = 1983702;
2534 fEnforceBIP30 = fEnforceBIP30 && (!pindexBIP34height || !(pindexBIP34height->
GetBlockHash() == params.GetConsensus().BIP34Hash));
2539 if (fEnforceBIP30 || pindex->
nHeight >= BIP34_IMPLIES_BIP30_LIMIT) {
2540 for (
const auto& tx : block.
vtx) {
2541 for (
size_t o = 0; o < tx->
vout.size(); o++) {
2544 "tried to overwrite transaction");
2551 int nLockTimeFlags = 0;
2559 const auto time_2{SteadyClock::now()};
2562 Ticks<MillisecondsDouble>(time_2 - time_1),
2567 LogInfo(
"%s signature validations at block #%d (%s).", fScriptChecks ?
"Enabling" :
"Disabling", pindex->
nHeight, block_hash.ToString());
2578 std::optional<CCheckQueueControl<CScriptCheck>> control;
2581 std::vector<PrecomputedTransactionData> txsdata(block.
vtx.size());
2583 std::vector<int> prevheights;
2586 int64_t nSigOpsCost = 0;
2587 blockundo.
vtxundo.reserve(block.
vtx.size() - 1);
2588 for (
unsigned int i = 0; i < block.
vtx.size(); i++)
2593 nInputs += tx.
vin.size();
2609 "accumulated fee in the block out of range");
2616 prevheights.resize(tx.
vin.size());
2617 for (
size_t j = 0; j < tx.
vin.size(); j++) {
2621 if (!
SequenceLocks(tx, nLockTimeFlags, prevheights, *pindex)) {
2640 bool fCacheResults = fJustCheck;
2646 std::vector<CScriptCheck> vChecks;
2648 if (tx_ok) control->Add(std::move(vChecks));
2662 blockundo.
vtxundo.emplace_back();
2666 const auto time_3{SteadyClock::now()};
2668 LogDebug(
BCLog::BENCH,
" - Connect %u transactions: %.2fms (%.3fms/tx, %.3fms/txin) [%.2fs (%.2fms/blk)]\n", (
unsigned)block.
vtx.size(),
2669 Ticks<MillisecondsDouble>(time_3 - time_2), Ticks<MillisecondsDouble>(time_3 - time_2) / block.
vtx.size(),
2670 nInputs <= 1 ? 0 : Ticks<MillisecondsDouble>(time_3 - time_2) / (nInputs - 1),
2671 Ticks<SecondsDouble>(
m_chainman.time_connect),
2675 if (block.
vtx[0]->GetValueOut() > blockReward && state.
IsValid()) {
2677 strprintf(
"coinbase pays too much (actual=%d vs limit=%d)", block.
vtx[0]->GetValueOut(), blockReward));
2680 auto parallel_result = control->Complete();
2681 if (parallel_result.has_value() && state.
IsValid()) {
2689 const auto time_4{SteadyClock::now()};
2691 LogDebug(
BCLog::BENCH,
" - Verify %u txins: %.2fms (%.3fms/txin) [%.2fs (%.2fms/blk)]\n", nInputs - 1,
2692 Ticks<MillisecondsDouble>(time_4 - time_2),
2693 nInputs <= 1 ? 0 : Ticks<MillisecondsDouble>(time_4 - time_2) / (nInputs - 1),
2694 Ticks<SecondsDouble>(
m_chainman.time_verify),
2701 if (!
m_blockman.WriteBlockUndo(blockundo, state, *pindex)) {
2705 const auto time_5{SteadyClock::now()};
2708 Ticks<MillisecondsDouble>(time_5 - time_4),
2720 const auto time_6{SteadyClock::now()};
2723 Ticks<MillisecondsDouble>(time_6 - time_5),
2733 Ticks<std::chrono::nanoseconds>(time_5 - time_start)
2742 return this->GetCoinsCacheSizeState(
2748 size_t max_coins_cache_size_bytes,
2749 size_t max_mempool_size_bytes)
2754 int64_t nTotalSpace =
2755 max_coins_cache_size_bytes + std::max<int64_t>(int64_t(max_mempool_size_bytes) - nMempoolUsage, 0);
2757 if (cacheSize > nTotalSpace) {
2758 LogPrintf(
"Cache size (%s) exceeds total space (%s)\n", cacheSize, nTotalSpace);
2769 int nManualPruneHeight)
2773 std::set<int> setFilesToPrune;
2774 bool full_flush_completed =
false;
2781 bool fFlushForPrune =
false;
2789 std::optional<std::string> limiting_lock;
2791 for (
const auto& prune_lock :
m_blockman.m_prune_locks) {
2792 if (prune_lock.second.height_first == std::numeric_limits<int>::max())
continue;
2795 last_prune = std::max(1, std::min(last_prune, lock_height));
2796 if (last_prune == lock_height) {
2797 limiting_lock = prune_lock.first;
2801 if (limiting_lock) {
2802 LogDebug(
BCLog::PRUNE,
"%s limited pruning to height %d\n", limiting_lock.value(), last_prune);
2805 if (nManualPruneHeight > 0) {
2810 std::min(last_prune, nManualPruneHeight),
2818 if (!setFilesToPrune.empty()) {
2819 fFlushForPrune =
true;
2821 m_blockman.m_block_tree_db->WriteFlag(
"prunedblockfiles",
true);
2834 bool should_write = (mode ==
FlushStateMode::ALWAYS) || fCacheLarge || fCacheCritical || fPeriodicWrite || fFlushForPrune;
2837 LogDebug(
BCLog::COINDB,
"Writing chainstate to disk: flush mode=%s, prune=%d, large=%d, critical=%d, periodic=%d",
2838 FlushStateModeNames[
size_t(mode)], fFlushForPrune, fCacheLarge, fCacheCritical, fPeriodicWrite);
2864 if (fFlushForPrune) {
2870 if (!
CoinsTip().GetBestBlock().IsNull()) {
2871 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);
2888 full_flush_completed =
true;
2890 int64_t{Ticks<std::chrono::microseconds>(
NodeClock::now() - nNow)},
2892 (uint64_t)coins_count,
2893 (uint64_t)coins_mem_usage,
2894 (
bool)fFlushForPrune);
2898 if (should_write ||
m_next_write == NodeClock::time_point::max()) {
2907 }
catch (
const std::runtime_error& e) {
2934 const std::string& func_name,
2935 const std::string&
prefix,
2947 chainman.GuessVerificationProgress(tip),
2950 !warning_messages.empty() ?
strprintf(
" warning='%s'", warning_messages) :
"");
2953void Chainstate::UpdateTip(
const CBlockIndex* pindexNew)
2956 const auto& coins_tip = this->
CoinsTip();
2962 constexpr int BACKGROUND_LOG_INTERVAL = 2000;
2963 if (pindexNew->
nHeight % BACKGROUND_LOG_INTERVAL == 0) {
2974 std::vector<bilingual_str> warning_messages;
2977 for (
auto [bit, active] : bits) {
2982 warning_messages.push_back(warning);
3009 std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
3012 LogError(
"DisconnectTip(): Failed to read block\n");
3016 const auto time_start{SteadyClock::now()};
3020 if (DisconnectBlock(block, pindexDelete, view) !=
DISCONNECT_OK) {
3024 bool flushed = view.
Flush();
3028 Ticks<MillisecondsDouble>(SteadyClock::now() - time_start));
3032 const int max_height_first{pindexDelete->
nHeight - 1};
3033 for (
auto& prune_lock :
m_blockman.m_prune_locks) {
3034 if (prune_lock.second.height_first <= max_height_first)
continue;
3036 prune_lock.second.height_first = max_height_first;
3037 LogDebug(
BCLog::PRUNE,
"%s prune lock moved back to %d\n", prune_lock.first, max_height_first);
3056 UpdateTip(pindexDelete->
pprev);
3114 std::shared_ptr<const CBlock> block_to_connect,
3123 const auto time_1{SteadyClock::now()};
3124 if (!block_to_connect) {
3125 std::shared_ptr<CBlock> pblockNew = std::make_shared<CBlock>();
3129 block_to_connect = std::move(pblockNew);
3134 const auto time_2{SteadyClock::now()};
3135 SteadyClock::time_point time_3;
3139 Ticks<MillisecondsDouble>(time_2 - time_1));
3142 bool rv =
ConnectBlock(*block_to_connect, state, pindexNew, view);
3152 time_3 = SteadyClock::now();
3153 m_chainman.time_connect_total += time_3 - time_2;
3156 Ticks<MillisecondsDouble>(time_3 - time_2),
3157 Ticks<SecondsDouble>(
m_chainman.time_connect_total),
3159 bool flushed = view.
Flush();
3162 const auto time_4{SteadyClock::now()};
3165 Ticks<MillisecondsDouble>(time_4 - time_3),
3172 const auto time_5{SteadyClock::now()};
3173 m_chainman.time_chainstate += time_5 - time_4;
3175 Ticks<MillisecondsDouble>(time_5 - time_4),
3176 Ticks<SecondsDouble>(
m_chainman.time_chainstate),
3185 UpdateTip(pindexNew);
3187 const auto time_6{SteadyClock::now()};
3188 m_chainman.time_post_connect += time_6 - time_5;
3191 Ticks<MillisecondsDouble>(time_6 - time_5),
3192 Ticks<SecondsDouble>(
m_chainman.time_post_connect),
3195 Ticks<MillisecondsDouble>(time_6 - time_1),
3204 m_chainman.MaybeCompleteSnapshotValidation();
3207 connectTrace.
BlockConnected(pindexNew, std::move(block_to_connect));
3232 bool fInvalidAncestor =
false;
3242 if (fFailedChain || fMissingData) {
3249 while (pindexTest != pindexFailed) {
3253 }
else if (fMissingData) {
3258 std::make_pair(pindexFailed->
pprev, pindexFailed));
3261 pindexFailed = pindexFailed->
pprev;
3264 fInvalidAncestor =
true;
3267 pindexTest = pindexTest->
pprev;
3269 if (!fInvalidAncestor)
3301 bool fBlocksDisconnected =
false;
3315 fBlocksDisconnected =
true;
3319 std::vector<CBlockIndex*> vpindexToConnect;
3320 bool fContinue =
true;
3325 int nTargetHeight = std::min(
nHeight + 32, pindexMostWork->
nHeight);
3326 vpindexToConnect.clear();
3327 vpindexToConnect.reserve(nTargetHeight -
nHeight);
3330 vpindexToConnect.push_back(pindexIter);
3331 pindexIter = pindexIter->
pprev;
3336 for (
CBlockIndex* pindexConnect : vpindexToConnect | std::views::reverse) {
3337 if (!
ConnectTip(state, pindexConnect, pindexConnect == pindexMostWork ? pblock : std::shared_ptr<const CBlock>(), connectTrace, disconnectpool)) {
3344 fInvalidFound =
true;
3365 if (fBlocksDisconnected) {
3386 bool fNotify =
false;
3387 bool fInitialBlockDownload =
false;
3391 pindexHeader = m_best_header;
3393 if (pindexHeader != m_last_notified_header) {
3396 m_last_notified_header = pindexHeader;
3409 if (signals.CallbacksPending() > 10) {
3410 signals.SyncWithValidationInterfaceQueue();
3414bool Chainstate::ActivateBestChain(
BlockValidationState& state, std::shared_ptr<const CBlock> pblock)
3433 LogPrintf(
"m_disabled is set - this chainstate should not be in operation. "
3434 "Please report this as a bug. %s\n", CLIENT_BUGREPORT);
3440 bool exited_ibd{
false};
3457 bool blocks_connected =
false;
3463 if (pindexMostWork ==
nullptr) {
3468 if (pindexMostWork ==
nullptr || pindexMostWork ==
m_chain.
Tip()) {
3472 bool fInvalidFound =
false;
3473 std::shared_ptr<const CBlock> nullBlockPtr;
3478 if (!
ActivateBestChainStep(state, pindexMostWork, pblock && pblock->GetHash() == pindexMostWork->
GetBlockHash() ? pblock : nullBlockPtr, fInvalidFound, connectTrace)) {
3482 blocks_connected =
true;
3484 if (fInvalidFound) {
3486 pindexMostWork =
nullptr;
3491 assert(trace.pblock && trace.pindex);
3506 if (!blocks_connected)
return true;
3511 if (was_in_ibd && !still_in_ibd) {
3571 }
while (pindexNewTip != pindexMostWork);
3611 return ActivateBestChain(state, std::shared_ptr<const CBlock>());
3621 if (pindex->
nHeight == 0)
return false;
3624 bool pindex_was_in_chain =
false;
3625 int disconnected = 0;
3639 std::multimap<const arith_uint256, CBlockIndex*> highpow_outofchain_headers;
3643 for (
auto& entry :
m_blockman.m_block_index) {
3653 highpow_outofchain_headers.insert({candidate->
nChainWork, candidate});
3670 pindex_was_in_chain =
true;
3683 if (!
ret)
return false;
3706 auto candidate_it = highpow_outofchain_headers.lower_bound(invalid_walk_tip->
pprev->
nChainWork);
3708 const bool best_header_needs_update{
m_chainman.m_best_header->GetAncestor(invalid_walk_tip->
nHeight) == invalid_walk_tip};
3709 if (best_header_needs_update) {
3714 while (candidate_it != highpow_outofchain_headers.end()) {
3718 candidate->nStatus &= ~BLOCK_FAILED_VALID;
3723 candidate_it = highpow_outofchain_headers.erase(candidate_it);
3733 if (best_header_needs_update &&
3742 to_mark_failed = invalid_walk_tip;
3768 for (
auto& [
_, block_index] :
m_blockman.m_block_index) {
3778 if (pindex_was_in_chain) {
3788 *to_mark_failed->
pprev,
3800void Chainstate::SetBlockFailureFlags(
CBlockIndex* invalid_block)
3804 for (
auto& [
_, block_index] :
m_blockman.m_block_index) {
3805 if (invalid_block != &block_index && block_index.GetAncestor(invalid_block->
nHeight) == invalid_block) {
3806 block_index.nStatus = (block_index.nStatus & ~BLOCK_FAILED_VALID) |
BLOCK_FAILED_CHILD;
3818 for (
auto& [
_, block_index] :
m_blockman.m_block_index) {
3820 block_index.nStatus &= ~BLOCK_FAILED_MASK;
3825 if (&block_index ==
m_chainman.m_best_invalid) {
3843 if (is_active_chainstate) {
3847 }
else if (!m_disabled) {
3852 if (snapshot_base->GetAncestor(pindex->
nHeight) == pindex) {
3862 pindexNew->
nTx = block.
vtx.size();
3868 auto prev_tx_sum = [](
CBlockIndex& block) {
return block.nTx + (block.pprev ? block.pprev->m_chain_tx_count : 0); };
3870 pindexNew == GetSnapshotBaseBlock())) {
3871 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",
3875 pindexNew->nFile = pos.
nFile;
3876 pindexNew->nDataPos = pos.
nPos;
3877 pindexNew->nUndoPos = 0;
3887 std::deque<CBlockIndex*> queue;
3888 queue.push_back(pindexNew);
3891 while (!queue.empty()) {
3899 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",
3905 c->TryAddBlockIndexCandidate(pindex);
3907 std::pair<std::multimap<CBlockIndex*, CBlockIndex*>::iterator, std::multimap<CBlockIndex*, CBlockIndex*>::iterator> range =
m_blockman.
m_blocks_unlinked.equal_range(pindex);
3908 while (range.first != range.second) {
3909 std::multimap<CBlockIndex*, CBlockIndex*>::iterator it = range.first;
3910 queue.push_back(it->second);
3941 "hashMerkleRoot mismatch");
3950 "bad-txns-duplicate",
3951 "duplicate transaction");
3966 if (expect_witness_commitment) {
3971 assert(!block.
vtx.empty() && !block.
vtx[0]->vin.empty());
3972 const auto& witness_stack{block.
vtx[0]->vin[0].scriptWitness.stack};
3974 if (witness_stack.size() != 1 || witness_stack[0].size() != 32) {
3977 "bad-witness-nonce-size",
3978 strprintf(
"%s : invalid witness reserved value size", __func__));
3987 if (memcmp(hash_witness.
begin(), &block.
vtx[0]->vout[commitpos].scriptPubKey[6], 32)) {
3990 "bad-witness-merkle-match",
3991 strprintf(
"%s : witness merkle commitment mismatch", __func__));
4000 for (
const auto& tx : block.
vtx) {
4004 "unexpected-witness",
4005 strprintf(
"%s : unexpected witness data found", __func__));
4045 if (block.
vtx.empty() || !block.
vtx[0]->IsCoinBase())
4047 for (
unsigned int i = 1; i < block.
vtx.size(); i++)
4048 if (block.
vtx[i]->IsCoinBase())
4053 for (
const auto& tx : block.
vtx) {
4065 unsigned int nSigOps = 0;
4066 for (
const auto& tx : block.
vtx)
4073 if (fCheckPOW && fCheckMerkleRoot)
4082 static const std::vector<unsigned char>
nonce(32, 0x00);
4085 tx.
vin[0].scriptWitness.stack.resize(1);
4086 tx.
vin[0].scriptWitness.stack[0] =
nonce;
4093 std::vector<unsigned char> commitment;
4095 std::vector<unsigned char>
ret(32, 0x00);
4103 out.scriptPubKey[1] = 0x24;
4104 out.scriptPubKey[2] = 0xaa;
4105 out.scriptPubKey[3] = 0x21;
4106 out.scriptPubKey[4] = 0xa9;
4107 out.scriptPubKey[5] = 0xed;
4108 memcpy(&
out.scriptPubKey[6], witnessroot.
begin(), 32);
4109 commitment = std::vector<unsigned char>(
out.scriptPubKey.begin(),
out.scriptPubKey.end());
4120 return std::all_of(headers.cbegin(), headers.cend(),
4121 [&](
const auto& header) { return CheckProofOfWork(header.GetHash(), header.nBits, consensusParams);});
4132 if (block.
vtx.empty() || !block.
vtx[0]->IsCoinBase()) {
4139 return std::any_of(block.
vtx.begin(), block.
vtx.end(),
4140 [](
auto& tx) { return GetSerializeSize(TX_NO_WITNESS(tx)) == 64; });
4181 assert(pindexPrev !=
nullptr);
4182 const int nHeight = pindexPrev->nHeight + 1;
4190 if (block.
GetBlockTime() <= pindexPrev->GetMedianTimePast())
4229 const int nHeight = pindexPrev ==
nullptr ? 0 : pindexPrev->
nHeight + 1;
4232 bool enforce_locktime_median_time_past{
false};
4234 assert(pindexPrev !=
nullptr);
4235 enforce_locktime_median_time_past =
true;
4238 const int64_t nLockTimeCutoff{enforce_locktime_median_time_past ?
4243 for (
const auto& tx : block.
vtx) {
4253 if (block.
vtx[0]->vin[0].scriptSig.size() <
expect.size() ||
4254 !std::equal(
expect.begin(),
expect.end(), block.
vtx[0]->vin[0].scriptSig.begin())) {
4290 BlockMap::iterator miSelf{
m_blockman.m_block_index.find(hash)};
4292 if (miSelf !=
m_blockman.m_block_index.end()) {
4316 pindexPrev = &((*mi).second);
4326 if (!min_pow_checked) {
4361 blocks_left = std::max<int64_t>(0, blocks_left);
4362 const double progress{100.0 * last_accepted.nHeight / (last_accepted.nHeight + blocks_left)};
4363 LogInfo(
"Synchronizing blockheaders, height: %d (~%.2f%%)\n", last_accepted.nHeight, progress);
4381 if (now < m_last_presync_update + std::chrono::milliseconds{250})
return;
4382 m_last_presync_update = now;
4386 if (initial_download) {
4388 blocks_left = std::max<int64_t>(0, blocks_left);
4389 const double progress{100.0 * height / (height + blocks_left)};
4390 LogInfo(
"Pre-synchronizing blockheaders, height: %d (~%.2f%%)\n", height, progress);
4397 const CBlock& block = *pblock;
4399 if (fNewBlock) *fNewBlock =
false;
4403 CBlockIndex *&pindex = ppindex ? *ppindex : pindexDummy;
4405 bool accepted_header{
AcceptBlockHeader(block, state, &pindex, min_pow_checked)};
4408 if (!accepted_header)
4432 if (fAlreadyHave)
return true;
4434 if (pindex->
nTx != 0)
return true;
4435 if (!fHasMoreOrSameWork)
return true;
4436 if (fTooFarAhead)
return true;
4447 if (!
CheckBlock(block, state, params.GetConsensus()) ||
4463 if (fNewBlock) *fNewBlock =
true;
4471 if (blockPos.IsNull()) {
4472 state.
Error(
strprintf(
"%s: Failed to find position to write new block to disk", __func__));
4477 }
catch (
const std::runtime_error& e) {
4501 if (new_block) *new_block =
false;
4516 ret =
AcceptBlock(block, state, &pindex, force_processing,
nullptr, new_block, min_pow_checked);
4531 LogError(
"%s: ActivateBestChain failed (%s)\n", __func__, state.
ToString());
4537 if (bg_chain && !bg_chain->ActivateBestChain(bg_state, block)) {
4538 LogError(
"%s: [background] ActivateBestChain failed (%s)\n", __func__, bg_state.
ToString());
4563 const bool check_pow,
4564 const bool check_merkle_root)
4575 state.
Invalid({},
"inconclusive-not-best-prevblk");
4616 index_dummy.pprev = tip;
4618 index_dummy.phashBlock = &block_hash;
4622 if(!chainstate.
ConnectBlock(block, state, &index_dummy, view_dummy,
true)) {
4663 LogInfo(
"Loaded best chain: hashBestChain=%s height=%d date=%s progress=%f",
4696 int nCheckLevel,
int nCheckDepth)
4705 if (nCheckDepth <= 0 || nCheckDepth > chainstate.
m_chain.
Height()) {
4708 nCheckLevel = std::max(0, std::min(4, nCheckLevel));
4709 LogInfo(
"Verifying last %i blocks at level %i", nCheckDepth, nCheckLevel);
4713 int nGoodTransactions = 0;
4716 bool skipped_no_block_data{
false};
4717 bool skipped_l3_checks{
false};
4718 LogInfo(
"Verification progress: 0%%");
4723 const int percentageDone = std::max(1, std::min(99, (
int)(((
double)(chainstate.
m_chain.
Height() - pindex->
nHeight)) / (
double)nCheckDepth * (nCheckLevel >= 4 ? 50 : 100))));
4724 if (reportDone < percentageDone / 10) {
4726 LogInfo(
"Verification progress: %d%%", percentageDone);
4727 reportDone = percentageDone / 10;
4736 LogInfo(
"Block verification stopping at height %d (no data). This could be due to pruning or use of an assumeutxo snapshot.", pindex->
nHeight);
4737 skipped_no_block_data =
true;
4747 if (nCheckLevel >= 1 && !
CheckBlock(block, state, consensus_params)) {
4748 LogPrintf(
"Verification error: found bad block at %d, hash=%s (%s)\n",
4753 if (nCheckLevel >= 2 && pindex) {
4765 if (nCheckLevel >= 3) {
4774 nGoodTransactions = 0;
4775 pindexFailure = pindex;
4777 nGoodTransactions += block.
vtx.size();
4780 skipped_l3_checks =
true;
4785 if (pindexFailure) {
4786 LogPrintf(
"Verification error: coin database inconsistencies found (last %i blocks, %i good transactions before that)\n", chainstate.
m_chain.
Height() - pindexFailure->
nHeight + 1, nGoodTransactions);
4789 if (skipped_l3_checks) {
4790 LogPrintf(
"Skipped verification of level >=3 (insufficient database cache size). Consider increasing -dbcache.\n");
4797 if (nCheckLevel >= 4 && !skipped_l3_checks) {
4799 const int percentageDone = std::max(1, std::min(99, 100 - (
int)(((
double)(chainstate.
m_chain.
Height() - pindex->
nHeight)) / (
double)nCheckDepth * 50)));
4800 if (reportDone < percentageDone / 10) {
4802 LogInfo(
"Verification progress: %d%%", percentageDone);
4803 reportDone = percentageDone / 10;
4812 if (!chainstate.
ConnectBlock(block, state, pindex, coins)) {
4820 LogInfo(
"Verification: No coin database inconsistencies in last %i blocks (%i transactions)", block_count, nGoodTransactions);
4822 if (skipped_l3_checks) {
4825 if (skipped_no_block_data) {
4843 if (!tx->IsCoinBase()) {
4844 for (
const CTxIn &txin : tx->vin) {
4862 if (hashHeads.empty())
return true;
4863 if (hashHeads.size() != 2) {
4864 LogError(
"ReplayBlocks(): unknown inconsistent state\n");
4875 if (
m_blockman.m_block_index.count(hashHeads[0]) == 0) {
4876 LogError(
"ReplayBlocks(): reorganization to unknown block requested\n");
4879 pindexNew = &(
m_blockman.m_block_index[hashHeads[0]]);
4881 if (!hashHeads[1].IsNull()) {
4882 if (
m_blockman.m_block_index.count(hashHeads[1]) == 0) {
4883 LogError(
"ReplayBlocks(): reorganization from unknown block requested\n");
4886 pindexOld = &(
m_blockman.m_block_index[hashHeads[1]]);
4888 assert(pindexFork !=
nullptr);
4892 while (pindexOld != pindexFork) {
4910 pindexOld = pindexOld->
pprev;
4914 int nForkHeight = pindexFork ? pindexFork->
nHeight : 0;
4941 block = block->pprev;
4947void Chainstate::ClearBlockIndexCandidates()
4959 if (!
ret)
return false;
4961 m_blockman.ScanAndUnlinkAlreadyPrunedFiles();
4963 std::vector<CBlockIndex*> vSortedByHeight{
m_blockman.GetAllBlockIndices()};
4964 std::sort(vSortedByHeight.begin(), vSortedByHeight.end(),
4974 if (pindex == GetSnapshotBaseBlock() ||
4979 chainstate->TryAddBlockIndexCandidate(pindex);
4983 m_best_invalid = pindex;
4986 m_best_header = pindex;
5002 if (
m_blockman.m_block_index.count(params.GenesisBlock().GetHash()))
5006 const CBlock& block = params.GenesisBlock();
5008 if (blockPos.IsNull()) {
5009 LogError(
"%s: writing genesis block to disk failed\n", __func__);
5014 }
catch (
const std::runtime_error& e) {
5015 LogError(
"%s: failed to write genesis block: %s\n", __func__, e.what());
5025 std::multimap<uint256, FlatFilePos>* blocks_with_unknown_parent)
5028 assert(!dbp == !blocks_with_unknown_parent);
5030 const auto start{SteadyClock::now()};
5038 uint64_t nRewind = blkdat.GetPos();
5039 while (!blkdat.eof()) {
5042 blkdat.SetPos(nRewind);
5045 unsigned int nSize = 0;
5049 blkdat.FindByte(std::byte(params.MessageStart()[0]));
5050 nRewind = blkdat.GetPos() + 1;
5052 if (buf != params.MessageStart()) {
5059 }
catch (
const std::exception&) {
5066 const uint64_t nBlockPos{blkdat.GetPos()};
5068 dbp->
nPos = nBlockPos;
5069 blkdat.SetLimit(nBlockPos + nSize);
5075 nRewind = nBlockPos + nSize;
5076 blkdat.SkipTo(nRewind);
5078 std::shared_ptr<CBlock> pblock{};
5086 if (dbp && blocks_with_unknown_parent) {
5087 blocks_with_unknown_parent->emplace(header.
hashPrevBlock, *dbp);
5096 blkdat.SetPos(nBlockPos);
5097 pblock = std::make_shared<CBlock>();
5099 nRewind = blkdat.GetPos();
5102 if (
AcceptBlock(pblock, state,
nullptr,
true, dbp,
nullptr,
true)) {
5108 }
else if (hash != params.GetConsensus().hashGenesisBlock && pindex->
nHeight % 1000 == 0) {
5135 bool activation_failure =
false;
5136 for (
auto c :
GetAll()) {
5138 if (!c->ActivateBestChain(state, pblock)) {
5140 activation_failure =
true;
5144 if (activation_failure) {
5151 if (!blocks_with_unknown_parent)
continue;
5154 std::deque<uint256> queue;
5155 queue.push_back(hash);
5156 while (!queue.empty()) {
5159 auto range = blocks_with_unknown_parent->equal_range(head);
5160 while (range.first != range.second) {
5161 std::multimap<uint256, FlatFilePos>::iterator it = range.first;
5162 std::shared_ptr<CBlock> pblockrecursive = std::make_shared<CBlock>();
5164 const auto& block_hash{pblockrecursive->GetHash()};
5168 if (
AcceptBlock(pblockrecursive, dummy,
nullptr,
true, &it->second,
nullptr,
true)) {
5170 queue.push_back(block_hash);
5174 blocks_with_unknown_parent->erase(it);
5178 }
catch (
const std::exception& e) {
5190 LogDebug(
BCLog::REINDEX,
"%s: unexpected data at file offset 0x%x - %s. continuing\n", __func__, (nRewind - 1), e.what());
5193 }
catch (
const std::runtime_error& e) {
5196 LogInfo(
"Loaded %i blocks from external file in %dms", nLoaded, Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
5231 best_hdr_chain.
SetTip(*m_best_header);
5233 std::multimap<const CBlockIndex*, const CBlockIndex*> forward;
5234 for (
auto& [
_, block_index] :
m_blockman.m_block_index) {
5236 if (!best_hdr_chain.
Contains(&block_index)) {
5238 assert(block_index.pprev);
5239 forward.emplace(block_index.pprev, &block_index);
5253 const CBlockIndex* pindexFirstNeverProcessed =
nullptr;
5254 const CBlockIndex* pindexFirstNotTreeValid =
nullptr;
5255 const CBlockIndex* pindexFirstNotTransactionsValid =
nullptr;
5256 const CBlockIndex* pindexFirstNotChainValid =
nullptr;
5257 const CBlockIndex* pindexFirstNotScriptsValid =
nullptr;
5263 const CBlockIndex* snap_base{GetSnapshotBaseBlock()};
5264 const CBlockIndex *snap_first_missing{}, *snap_first_notx{}, *snap_first_notv{}, *snap_first_nocv{}, *snap_first_nosv{};
5265 auto snap_update_firsts = [&] {
5266 if (pindex == snap_base) {
5267 std::swap(snap_first_missing, pindexFirstMissing);
5268 std::swap(snap_first_notx, pindexFirstNeverProcessed);
5269 std::swap(snap_first_notv, pindexFirstNotTransactionsValid);
5270 std::swap(snap_first_nocv, pindexFirstNotChainValid);
5271 std::swap(snap_first_nosv, pindexFirstNotScriptsValid);
5275 while (pindex !=
nullptr) {
5277 if (pindexFirstInvalid ==
nullptr && pindex->nStatus &
BLOCK_FAILED_VALID) pindexFirstInvalid = pindex;
5278 if (pindexFirstMissing ==
nullptr && !(pindex->nStatus &
BLOCK_HAVE_DATA)) {
5279 pindexFirstMissing = pindex;
5281 if (pindexFirstNeverProcessed ==
nullptr && pindex->
nTx == 0) pindexFirstNeverProcessed = pindex;
5284 if (pindex->
pprev !=
nullptr) {
5285 if (pindexFirstNotTransactionsValid ==
nullptr &&
5287 pindexFirstNotTransactionsValid = pindex;
5290 if (pindexFirstNotChainValid ==
nullptr &&
5292 pindexFirstNotChainValid = pindex;
5295 if (pindexFirstNotScriptsValid ==
nullptr &&
5297 pindexFirstNotScriptsValid = pindex;
5302 if (pindex->
pprev ==
nullptr) {
5305 for (
const Chainstate* c : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) {
5306 if (c && c->m_chain.Genesis() !=
nullptr) {
5307 assert(pindex == c->m_chain.Genesis());
5317 assert(pindexFirstMissing == pindexFirstNeverProcessed);
5323 if (snap_base && snap_base->GetAncestor(pindex->
nHeight) == pindex) {
5333 assert((pindexFirstNotTransactionsValid ==
nullptr || pindex == snap_base) == pindex->
HaveNumChainTxs());
5337 assert(pindexFirstNotTreeValid ==
nullptr);
5341 if (pindexFirstInvalid ==
nullptr) {
5348 if (!pindex->
pprev) {
5363 for (
const Chainstate* c : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) {
5364 if (!c || c->m_chain.Tip() ==
nullptr)
continue;
5378 if (!
CBlockIndexWorkComparator()(pindex, c->m_chain.Tip()) && (pindexFirstNeverProcessed ==
nullptr || pindex == snap_base)) {
5382 if (pindexFirstInvalid ==
nullptr) {
5401 if (pindexFirstMissing ==
nullptr || pindex == c->m_chain.Tip() || pindex == c->SnapshotBase()) {
5421 bool foundInUnlinked =
false;
5422 while (rangeUnlinked.first != rangeUnlinked.second) {
5423 assert(rangeUnlinked.first->first == pindex->
pprev);
5424 if (rangeUnlinked.first->second == pindex) {
5425 foundInUnlinked =
true;
5428 rangeUnlinked.first++;
5430 if (pindex->
pprev && (pindex->nStatus &
BLOCK_HAVE_DATA) && pindexFirstNeverProcessed !=
nullptr && pindexFirstInvalid ==
nullptr) {
5435 if (pindexFirstMissing ==
nullptr)
assert(!foundInUnlinked);
5436 if (pindex->
pprev && (pindex->nStatus &
BLOCK_HAVE_DATA) && pindexFirstNeverProcessed ==
nullptr && pindexFirstMissing !=
nullptr) {
5447 for (
const Chainstate* c : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) {
5451 if (pindexFirstInvalid ==
nullptr) {
5452 if (is_active || snap_base->GetAncestor(pindex->
nHeight) == pindex) {
5464 snap_update_firsts();
5465 auto range{forward.equal_range(pindex)};
5466 if (range.first != range.second) {
5468 pindex = range.first->second;
5471 }
else if (best_hdr_chain.
Contains(pindex)) {
5474 pindex = best_hdr_chain[
nHeight];
5482 snap_update_firsts();
5484 if (pindex == pindexFirstInvalid) pindexFirstInvalid =
nullptr;
5485 if (pindex == pindexFirstMissing) pindexFirstMissing =
nullptr;
5486 if (pindex == pindexFirstNeverProcessed) pindexFirstNeverProcessed =
nullptr;
5487 if (pindex == pindexFirstNotTreeValid) pindexFirstNotTreeValid =
nullptr;
5488 if (pindex == pindexFirstNotTransactionsValid) pindexFirstNotTransactionsValid =
nullptr;
5489 if (pindex == pindexFirstNotChainValid) pindexFirstNotChainValid =
nullptr;
5490 if (pindex == pindexFirstNotScriptsValid) pindexFirstNotScriptsValid =
nullptr;
5494 auto rangePar{forward.equal_range(pindexPar)};
5495 while (rangePar.first->second != pindex) {
5496 assert(rangePar.first != rangePar.second);
5501 if (rangePar.first != rangePar.second) {
5503 pindex = rangePar.first->second;
5505 }
else if (pindexPar == best_hdr_chain[
nHeight - 1]) {
5507 pindex = best_hdr_chain[
nHeight];
5509 assert((pindex ==
nullptr) == (pindexPar == best_hdr_chain.
Tip()));
5521 assert(nNodes == forward.size() + best_hdr_chain.
Height() + 1);
5528 return strprintf(
"Chainstate [%s] @ height %d (%s)",
5533bool Chainstate::ResizeCoinsCaches(
size_t coinstip_size,
size_t coinsdb_size)
5546 LogInfo(
"[%s] resized coinsdb cache to %.1f MiB",
5547 this->
ToString(), coinsdb_size * (1.0 / 1024 / 1024));
5548 LogInfo(
"[%s] resized coinstip cache to %.1f MiB",
5549 this->
ToString(), coinstip_size * (1.0 / 1024 / 1024));
5554 if (coinstip_size > old_coinstip_size) {
5568 if (pindex ==
nullptr) {
5577 const int64_t nNow{TicksSinceEpoch<std::chrono::seconds>(
NodeClock::now())};
5578 const auto block_time{
5579 (
Assume(m_best_header) && std::abs(nNow - pindex->
GetBlockTime()) <= Ticks<std::chrono::seconds>(2h) &&
5593 fTxTotal =
data.tx_count + (nNow -
data.nTime) *
data.dTxRate;
5604 if (m_active_chainstate && m_active_chainstate->m_from_snapshot_blockhash) {
5606 return m_active_chainstate->m_from_snapshot_blockhash;
5608 return std::nullopt;
5614 std::vector<Chainstate*>
out;
5616 for (
Chainstate*
cs : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) {
5626 assert(!m_ibd_chainstate);
5627 assert(!m_active_chainstate);
5629 m_ibd_chainstate = std::make_unique<Chainstate>(mempool,
m_blockman, *
this);
5630 m_active_chainstate = m_ibd_chainstate.get();
5631 return *m_active_chainstate;
5643 bool existed = fs::remove(base_blockhash_path);
5645 LogPrintf(
"[snapshot] snapshot chainstate dir being removed lacks %s file\n",
5648 }
catch (
const fs::filesystem_error& e) {
5649 LogWarning(
"[snapshot] failed to remove file %s: %s\n",
5655 LogInfo(
"Removing leveldb dir at %s\n", path_str);
5659 const bool destroyed =
DestroyDB(path_str);
5662 LogPrintf(
"error: leveldb DestroyDB call failed on %s\n", path_str);
5690 if (!
GetParams().AssumeutxoForBlockhash(base_blockhash).has_value()) {
5692 std::string heights_formatted =
util::Join(available_heights,
", ", [&](
const auto& i) {
return util::ToString(i); });
5693 return util::Error{
Untranslated(
strprintf(
"assumeutxo block hash in snapshot metadata not recognized (hash: %s). The following snapshot heights are available: %s",
5695 heights_formatted))};
5699 if (!snapshot_start_block) {
5700 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",
5705 if (start_block_invalid) {
5709 if (!m_best_header || m_best_header->GetAncestor(snapshot_start_block->nHeight) != snapshot_start_block) {
5710 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.")};
5713 auto mempool{m_active_chainstate->GetMempool()};
5714 if (mempool && mempool->
size() > 0) {
5719 int64_t current_coinsdb_cache_size{0};
5720 int64_t current_coinstip_cache_size{0};
5728 static constexpr double IBD_CACHE_PERC = 0.01;
5729 static constexpr double SNAPSHOT_CACHE_PERC = 0.99;
5741 current_coinsdb_cache_size = this->
ActiveChainstate().m_coinsdb_cache_size_bytes;
5742 current_coinstip_cache_size = this->
ActiveChainstate().m_coinstip_cache_size_bytes;
5747 static_cast<size_t>(current_coinstip_cache_size * IBD_CACHE_PERC),
5748 static_cast<size_t>(current_coinsdb_cache_size * IBD_CACHE_PERC));
5752 return std::make_unique<Chainstate>(
5753 nullptr,
m_blockman, *
this, base_blockhash));
5757 snapshot_chainstate->InitCoinsDB(
5758 static_cast<size_t>(current_coinsdb_cache_size * SNAPSHOT_CACHE_PERC),
5759 in_memory,
false,
"chainstate");
5760 snapshot_chainstate->InitCoinsCache(
5761 static_cast<size_t>(current_coinstip_cache_size * SNAPSHOT_CACHE_PERC));
5765 this->MaybeRebalanceCaches();
5773 snapshot_chainstate.reset();
5777 "Manually remove it before restarting.\n"),
fs::PathToString(*snapshot_datadir)));
5794 return cleanup_bad_snapshot(
Untranslated(
"work does not exceed active chainstate"));
5800 return cleanup_bad_snapshot(
Untranslated(
"could not write base blockhash"));
5804 assert(!m_snapshot_chainstate);
5805 m_snapshot_chainstate.swap(snapshot_chainstate);
5806 const bool chaintip_loaded = m_snapshot_chainstate->LoadChainTip();
5811 Assert(m_active_chainstate->m_mempool->size() == 0);
5812 Assert(!m_snapshot_chainstate->m_mempool);
5813 m_snapshot_chainstate->m_mempool = m_active_chainstate->m_mempool;
5814 m_active_chainstate->m_mempool =
nullptr;
5815 m_active_chainstate = m_snapshot_chainstate.get();
5818 LogInfo(
"[snapshot] successfully activated snapshot %s", base_blockhash.
ToString());
5819 LogInfo(
"[snapshot] (%.2f MB)",
5820 m_snapshot_chainstate->CoinsTip().DynamicMemoryUsage() / (1000 * 1000));
5822 this->MaybeRebalanceCaches();
5823 return snapshot_start_block;
5830 snapshot_loaded ?
"saving snapshot chainstate" :
"flushing coins cache",
5834 coins_cache.
Flush();
5839 const char*
what() const noexcept
override
5841 return "ComputeUTXOStats interrupted.";
5863 if (!snapshot_start_block) {
5870 int base_height = snapshot_start_block->
nHeight;
5873 if (!maybe_au_data) {
5875 "(%d) - refusing to load snapshot", base_height))};
5890 LogInfo(
"[snapshot] loading %d coins from snapshot %s", coins_left, base_blockhash.
ToString());
5891 int64_t coins_processed{0};
5893 while (coins_left > 0) {
5897 size_t coins_per_txid{0};
5900 if (coins_per_txid > coins_left) {
5904 for (
size_t i = 0; i < coins_per_txid; i++) {
5908 outpoint.
hash = txid;
5910 if (coin.
nHeight > base_height ||
5911 outpoint.
n >= std::numeric_limits<
decltype(outpoint.
n)>::max()
5914 coins_count - coins_left))};
5918 coins_count - coins_left))};
5925 if (coins_processed % 1000000 == 0) {
5926 LogInfo(
"[snapshot] %d coins loaded (%.2f%%, %.2f MB)",
5928 static_cast<float>(coins_processed) * 100 /
static_cast<float>(coins_count),
5936 if (coins_processed % 120000 == 0) {
5942 return snapshot_chainstate.GetCoinsCacheSizeState());
5955 }
catch (
const std::ios_base::failure&) {
5968 bool out_of_coins{
false};
5970 std::byte left_over_byte;
5971 coins_file >> left_over_byte;
5972 }
catch (
const std::ios_base::failure&) {
5974 out_of_coins =
true;
5976 if (!out_of_coins) {
5981 LogInfo(
"[snapshot] loaded %d (%.2f MB) coins from snapshot %s",
5995 std::optional<CCoinsStats> maybe_stats;
6003 if (!maybe_stats.has_value()) {
6024 constexpr int AFTER_GENESIS_START{1};
6026 for (
int i = AFTER_GENESIS_START; i <= snapshot_chainstate.
m_chain.
Height(); ++i) {
6027 index = snapshot_chainstate.
m_chain[i];
6044 assert(index == snapshot_start_block);
6048 LogInfo(
"[snapshot] validated snapshot (%.2f MB)",
6070 if (m_ibd_chainstate.get() == &this->ActiveChainstate() ||
6071 !this->IsUsable(m_snapshot_chainstate.get()) ||
6072 !this->IsUsable(m_ibd_chainstate.get()) ||
6073 !m_ibd_chainstate->m_chain.Tip()) {
6079 const int snapshot_base_height = *
Assert(this->GetSnapshotBaseHeight());
6082 if (index_new.
nHeight < snapshot_base_height) {
6092 "%s failed to validate the -assumeutxo snapshot state. "
6093 "This indicates a hardware problem, or a bug in the software, or a "
6094 "bad software modification that allowed an invalid snapshot to be "
6095 "loaded. As a result of this, the node will shut down and stop using any "
6096 "state that was built on the snapshot, resetting the chain height "
6097 "from %d to %d. On the next "
6098 "restart, the node will resume syncing from %d "
6099 "without using any snapshot data. "
6100 "Please report this incident to %s, including how you obtained the snapshot. "
6101 "The invalid snapshot chainstate will be left on disk in case it is "
6102 "helpful in diagnosing the issue that caused this error."),
6103 CLIENT_NAME, snapshot_tip_height, snapshot_base_height, snapshot_base_height, CLIENT_BUGREPORT
6107 LogError(
"[snapshot] deleting snapshot, reverting to validated chain, and stopping node\n");
6109 m_active_chainstate = m_ibd_chainstate.get();
6110 m_snapshot_chainstate->m_disabled =
true;
6114 auto rename_result = m_snapshot_chainstate->InvalidateCoinsDBOnDisk();
6115 if (!rename_result) {
6123 LogPrintf(
"[snapshot] supposed base block %s does not match the "
6124 "snapshot base block %s (height %d). Snapshot is not valid.\n",
6125 index_new.
ToString(), snapshot_blockhash.
ToString(), snapshot_base_height);
6126 handle_invalid_snapshot();
6132 int curr_height = m_ibd_chainstate->m_chain.Height();
6134 assert(snapshot_base_height == curr_height);
6139 CCoinsViewDB& ibd_coins_db = m_ibd_chainstate->CoinsDB();
6140 m_ibd_chainstate->ForceFlushStateToDisk();
6143 if (!maybe_au_data) {
6144 LogPrintf(
"[snapshot] assumeutxo data not found for height "
6145 "(%d) - refusing to validate snapshot\n", curr_height);
6146 handle_invalid_snapshot();
6151 std::optional<CCoinsStats> maybe_ibd_stats;
6152 LogInfo(
"[snapshot] computing UTXO stats for background chainstate to validate "
6153 "snapshot - this could take a few minutes");
6156 CoinStatsHashType::HASH_SERIALIZED,
6165 if (!maybe_ibd_stats) {
6166 LogPrintf(
"[snapshot] failed to generate stats for validation coins db\n");
6170 handle_invalid_snapshot();
6173 const auto& ibd_stats = *maybe_ibd_stats;
6182 LogPrintf(
"[snapshot] hash mismatch: actual=%s, expected=%s\n",
6183 ibd_stats.hashSerialized.ToString(),
6185 handle_invalid_snapshot();
6189 LogInfo(
"[snapshot] snapshot beginning at %s has been fully validated",
6192 m_ibd_chainstate->m_disabled =
true;
6193 this->MaybeRebalanceCaches();
6201 assert(m_active_chainstate);
6202 return *m_active_chainstate;
6208 return m_snapshot_chainstate && m_active_chainstate == m_snapshot_chainstate.get();
6211void ChainstateManager::MaybeRebalanceCaches()
6214 bool ibd_usable = this->
IsUsable(m_ibd_chainstate.get());
6215 bool snapshot_usable = this->
IsUsable(m_snapshot_chainstate.get());
6216 assert(ibd_usable || snapshot_usable);
6218 if (ibd_usable && !snapshot_usable) {
6223 else if (snapshot_usable && !ibd_usable) {
6225 LogInfo(
"[snapshot] allocating all cache to the snapshot chainstate");
6229 else if (ibd_usable && snapshot_usable) {
6234 m_ibd_chainstate->ResizeCoinsCaches(
6236 m_snapshot_chainstate->ResizeCoinsCaches(
6239 m_snapshot_chainstate->ResizeCoinsCaches(
6241 m_ibd_chainstate->ResizeCoinsCaches(
6247void ChainstateManager::ResetChainstates()
6249 m_ibd_chainstate.reset();
6250 m_snapshot_chainstate.reset();
6251 m_active_chainstate =
nullptr;
6261 if (!opts.check_block_index.has_value()) opts.
check_block_index = opts.chainparams.DefaultConsistencyChecks();
6262 if (!opts.minimum_chain_work.has_value()) opts.minimum_chain_work =
UintToArith256(opts.chainparams.GetConsensus().nMinimumChainWork);
6263 if (!opts.assumed_valid_block.has_value()) opts.assumed_valid_block = opts.chainparams.GetConsensus().defaultAssumeValid;
6264 return std::move(opts);
6269 m_interrupt{interrupt},
6271 m_blockman{interrupt,
std::move(blockman_options)},
6272 m_validation_cache{m_options.script_execution_cache_bytes, m_options.signature_cache_bytes}
6283bool ChainstateManager::DetectSnapshotChainstate()
6285 assert(!m_snapshot_chainstate);
6291 if (!base_blockhash) {
6294 LogInfo(
"[snapshot] detected active snapshot chainstate (%s) - loading",
6295 fs::PathToString(*path));
6297 this->ActivateExistingSnapshot(*base_blockhash);
6303 assert(!m_snapshot_chainstate);
6304 m_snapshot_chainstate =
6305 std::make_unique<Chainstate>(
nullptr,
m_blockman, *
this, base_blockhash);
6306 LogInfo(
"[snapshot] switching active chainstate to %s", m_snapshot_chainstate->ToString());
6309 Assert(m_active_chainstate->m_mempool->size() == 0);
6310 Assert(!m_snapshot_chainstate->m_mempool);
6311 m_snapshot_chainstate->m_mempool = m_active_chainstate->m_mempool;
6312 m_active_chainstate->m_mempool =
nullptr;
6313 m_active_chainstate = m_snapshot_chainstate.get();
6314 return *m_snapshot_chainstate;
6319 return (block_index.
nHeight==91842 && block_index.
GetBlockHash() ==
uint256{
"00000000000a4d0a398161ffc163c503763b1f4360639393e0e4c8e300e0caec"}) ||
6320 (block_index.
nHeight==91880 && block_index.
GetBlockHash() ==
uint256{
"00000000000743f190a18c5577a3c2d2a1f610ae9601ac046a38084ccb7cd721"});
6325 return (block_height==91722 && block_hash ==
uint256{
"00000000000271a2dc26e7667f8419f2e15416dc6955e5a6c6cdf3f2574dd08e"}) ||
6326 (block_height==91812 && block_hash ==
uint256{
"00000000000af0aed4792b1acee3d966af36cf5def14935db8de83d6f9306f2f"});
6333 assert(
cs.m_from_snapshot_blockhash);
6334 auto storage_path_maybe =
cs.CoinsDB().StoragePath();
6336 assert(storage_path_maybe);
6337 return *storage_path_maybe;
6347 auto invalid_path = snapshot_datadir +
"_INVALID";
6350 LogInfo(
"[snapshot] renaming snapshot datadir %s to %s", dbpath, target);
6356 fs::rename(snapshot_datadir, invalid_path);
6357 }
catch (
const fs::filesystem_error& e) {
6361 LogPrintf(
"%s: error renaming file '%s' -> '%s': %s\n",
6362 __func__, src_str, dest_str, e.what());
6364 "Rename of '%s' -> '%s' failed. "
6365 "You should resolve this by manually moving or deleting the invalid "
6366 "snapshot directory %s, otherwise you will encounter the same error again "
6367 "on the next startup."),
6368 src_str, dest_str, src_str)};
6373bool ChainstateManager::DeleteSnapshotChainstate()
6376 Assert(m_snapshot_chainstate);
6377 Assert(m_ibd_chainstate);
6381 LogPrintf(
"Deletion of %s failed. Please remove it manually to continue reindexing.\n",
6382 fs::PathToString(snapshot_datadir));
6385 m_active_chainstate = m_ibd_chainstate.get();
6386 m_active_chainstate->m_mempool = m_snapshot_chainstate->m_mempool;
6387 m_snapshot_chainstate.reset();
6401const CBlockIndex* ChainstateManager::GetSnapshotBaseBlock()
const
6403 return m_active_chainstate ? m_active_chainstate->SnapshotBase() :
nullptr;
6406std::optional<int> ChainstateManager::GetSnapshotBaseHeight()
const
6408 const CBlockIndex* base = this->GetSnapshotBaseBlock();
6409 return base ? std::make_optional(base->
nHeight) :
std::nullopt;
6412void ChainstateManager::RecalculateBestHeader()
6416 for (
auto& entry :
m_blockman.m_block_index) {
6417 if (!(entry.second.nStatus &
BLOCK_FAILED_MASK) && m_best_header->nChainWork < entry.second.nChainWork) {
6418 m_best_header = &entry.second;
6423bool ChainstateManager::ValidatedSnapshotCleanup()
6427 if (!(chainstate && chainstate->HasCoinsViews())) {
6430 return chainstate->CoinsDB().StoragePath();
6432 std::optional<fs::path> ibd_chainstate_path_maybe = get_storage_path(m_ibd_chainstate);
6433 std::optional<fs::path> snapshot_chainstate_path_maybe = get_storage_path(m_snapshot_chainstate);
6442 if (!ibd_chainstate_path_maybe || !snapshot_chainstate_path_maybe) {
6443 LogPrintf(
"[snapshot] snapshot chainstate cleanup cannot happen with "
6444 "in-memory chainstates. You are testing, right?\n");
6448 const auto& snapshot_chainstate_path = *snapshot_chainstate_path_maybe;
6449 const auto& ibd_chainstate_path = *ibd_chainstate_path_maybe;
6457 this->ResetChainstates();
6462 LogInfo(
"[snapshot] deleting background chainstate directory (now unnecessary) (%s)",
6463 fs::PathToString(ibd_chainstate_path));
6465 fs::path tmp_old{ibd_chainstate_path +
"_todelete"};
6467 auto rename_failed_abort = [
this](
6470 const fs::filesystem_error& err) {
6471 LogError(
"[snapshot] Error renaming path (%s) -> (%s): %s\n",
6472 fs::PathToString(p_old), fs::PathToString(p_new), err.what());
6474 "Rename of '%s' -> '%s' failed. "
6475 "Cannot clean up the background chainstate leveldb directory."),
6476 fs::PathToString(p_old), fs::PathToString(p_new)));
6480 fs::rename(ibd_chainstate_path, tmp_old);
6481 }
catch (
const fs::filesystem_error& e) {
6482 rename_failed_abort(ibd_chainstate_path, tmp_old, e);
6486 LogInfo(
"[snapshot] moving snapshot chainstate (%s) to "
6487 "default chainstate directory (%s)",
6488 fs::PathToString(snapshot_chainstate_path), fs::PathToString(ibd_chainstate_path));
6491 fs::rename(snapshot_chainstate_path, ibd_chainstate_path);
6492 }
catch (
const fs::filesystem_error& e) {
6493 rename_failed_abort(snapshot_chainstate_path, ibd_chainstate_path, e);
6500 LogPrintf(
"Deletion of %s failed. Please remove it manually, as the "
6501 "directory is now unnecessary.\n",
6502 fs::PathToString(tmp_old));
6504 LogInfo(
"[snapshot] deleted background chainstate directory (%s)",
6505 fs::PathToString(ibd_chainstate_path));
6510Chainstate& ChainstateManager::GetChainstateForIndexing()
6515 return (this->
GetAll().size() > 1) ? *m_ibd_chainstate : *m_active_chainstate;
6518std::pair<int, int> ChainstateManager::GetPruneRange(
const Chainstate& chainstate,
int last_height_can_prune)
6525 if (this->
GetAll().size() > 1 && m_snapshot_chainstate.get() == &chainstate) {
6528 prune_start = *
Assert(GetSnapshotBaseHeight()) + 1;
6531 int max_prune = std::max<int>(
6540 int prune_end = std::min(last_height_can_prune, max_prune);
6542 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 InterruptResult blockTip(SynchronizationState state, CBlockIndex &index, double verification_progress)
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 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.