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);
270 int expired = pool.Expire(GetTime<std::chrono::seconds>() - pool.m_opts.expiry);
275 std::vector<COutPoint> vNoSpendsRemaining;
276 pool.TrimToSize(pool.m_opts.max_size_bytes, &vNoSpendsRemaining);
277 for (
const COutPoint& removed : vNoSpendsRemaining)
278 coins_cache.Uncache(removed);
284 if (active_chainstate.m_chainman.IsInitialBlockDownload()) {
289 if (active_chainstate.m_chain.Height() < active_chainstate.m_chainman.m_best_header->nHeight - 1) {
303 std::vector<Txid> vHashUpdate;
310 const auto queuedTx = disconnectpool.
take();
311 auto it = queuedTx.rbegin();
312 while (it != queuedTx.rend()) {
314 if (!fAddToMempool || (*it)->IsCoinBase() ||
316 true,
false).m_result_type !=
322 vHashUpdate.push_back((*it)->GetHash());
363 it->UpdateLockPoints(*new_lock_points);
370 if (it->GetSpendsCoinbase()) {
376 if (coin.IsCoinBase() && mempool_spend_height - coin.nHeight <
COINBASE_MATURITY) {
412 if (coin.
IsSpent())
return false;
442 m_viewmempool(&active_chainstate.CoinsTip(), m_pool),
443 m_active_chainstate(active_chainstate)
451 const int64_t m_accept_time;
452 const bool m_bypass_limits;
460 std::vector<COutPoint>& m_coins_to_uncache;
462 const bool m_test_accept;
466 const bool m_allow_replacement;
468 const bool m_allow_sibling_eviction;
471 const bool m_package_submission;
475 const bool m_package_feerates;
480 const std::optional<CFeeRate> m_client_maxfeerate;
483 const bool m_allow_carveouts;
486 static ATMPArgs SingleAccept(
const CChainParams& chainparams, int64_t accept_time,
487 bool bypass_limits, std::vector<COutPoint>& coins_to_uncache,
489 return ATMPArgs{ chainparams,
504 static ATMPArgs PackageTestAccept(
const CChainParams& chainparams, int64_t accept_time,
505 std::vector<COutPoint>& coins_to_uncache) {
506 return ATMPArgs{ chainparams,
521 static ATMPArgs PackageChildWithParents(
const CChainParams& chainparams, int64_t accept_time,
522 std::vector<COutPoint>& coins_to_uncache,
const std::optional<CFeeRate>& client_maxfeerate) {
523 return ATMPArgs{ chainparams,
538 static ATMPArgs SingleInPackageAccept(
const ATMPArgs& package_args) {
539 return ATMPArgs{ package_args.m_chainparams,
540 package_args.m_accept_time,
542 package_args.m_coins_to_uncache,
543 package_args.m_test_accept,
548 package_args.m_client_maxfeerate,
559 std::vector<COutPoint>& coins_to_uncache,
561 bool allow_replacement,
562 bool allow_sibling_eviction,
563 bool package_submission,
564 bool package_feerates,
565 std::optional<CFeeRate> client_maxfeerate,
566 bool allow_carveouts)
567 : m_chainparams{chainparams},
568 m_accept_time{accept_time},
569 m_bypass_limits{bypass_limits},
570 m_coins_to_uncache{coins_to_uncache},
571 m_test_accept{test_accept},
572 m_allow_replacement{allow_replacement},
573 m_allow_sibling_eviction{allow_sibling_eviction},
574 m_package_submission{package_submission},
575 m_package_feerates{package_feerates},
576 m_client_maxfeerate{client_maxfeerate},
577 m_allow_carveouts{allow_carveouts}
581 if (m_package_feerates) {
582 Assume(m_package_submission);
583 Assume(!m_allow_carveouts);
584 Assume(!m_allow_sibling_eviction);
586 if (m_allow_sibling_eviction)
Assume(m_allow_replacement);
626 explicit Workspace(
const CTransactionRef& ptx) : m_ptx(ptx), m_hash(ptx->GetHash()) {}
629 std::set<Txid> m_conflicts;
639 bool m_sibling_eviction{
false};
674 bool PackageMempoolChecks(
const std::vector<CTransactionRef>& txns,
675 std::vector<Workspace>& workspaces,
696 std::map<Wtxid, MempoolAcceptResult>& results)
704 CAmount mempoolRejectFee = m_pool.GetMinFee().GetFee(package_size);
705 if (mempoolRejectFee > 0 && package_fee < mempoolRejectFee) {
709 if (package_fee < m_pool.m_opts.min_relay_feerate.GetFee(package_size)) {
711 strprintf(
"%d < %d", package_fee, m_pool.m_opts.min_relay_feerate.GetFee(package_size)));
718 return m_active_chainstate.m_chainman.m_validation_cache;
750 struct SubPackageState {
752 CAmount m_total_modified_fees{0};
754 int64_t m_total_vsize{0};
761 std::list<CTransactionRef> m_replaced_transactions;
763 std::unique_ptr<CTxMemPool::ChangeSet> m_changeset;
768 size_t m_conflicting_size{0};
771 struct SubPackageState m_subpackage;
776 m_subpackage = SubPackageState{};
779 CleanupTemporaryCoins();
783bool MemPoolAccept::PreChecks(ATMPArgs&
args, Workspace& ws)
789 const Txid& hash = ws.m_hash;
792 const int64_t nAcceptTime =
args.m_accept_time;
793 const bool bypass_limits =
args.m_bypass_limits;
794 std::vector<COutPoint>& coins_to_uncache =
args.m_coins_to_uncache;
809 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)) {
827 }
else if (m_pool.exists(tx.
GetHash())) {
837 if (ptxConflicting) {
838 if (!
args.m_allow_replacement) {
842 ws.m_conflicts.insert(ptxConflicting->
GetHash());
846 m_view.SetBackend(m_viewmempool);
852 coins_to_uncache.push_back(txin.
prevout);
858 if (!m_view.HaveCoin(txin.
prevout)) {
873 m_view.GetBestBlock();
878 m_view.SetBackend(m_dummy);
880 assert(m_active_chainstate.m_blockman.LookupBlockIndex(m_view.GetBestBlock()) == m_active_chainstate.m_chain.Tip());
887 const std::optional<LockPoints> lock_points{
CalculateLockPointsAtTip(m_active_chainstate.m_chain.Tip(), m_view, tx)};
910 bool fSpendsCoinbase =
false;
912 const Coin &coin = m_view.AccessCoin(txin.
prevout);
914 fSpendsCoinbase =
true;
921 const uint64_t entry_sequence = bypass_limits ? 0 : m_pool.GetSequence();
922 if (!m_subpackage.m_changeset) {
923 m_subpackage.m_changeset = m_pool.GetChangeSet();
925 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());
928 ws.m_modified_fees = ws.m_tx_handle->GetModifiedFee();
930 ws.m_vsize = ws.m_tx_handle->GetTxSize();
933 if (m_pool.m_opts.require_standard) {
934 if (!
PreCheckEphemeralTx(*ptx, m_pool.m_opts.dust_relay_feerate, ws.m_base_fees, ws.m_modified_fees, state)) {
949 if (!bypass_limits && ws.m_ptx->version !=
TRUC_VERSION && ws.m_modified_fees < m_pool.m_opts.min_relay_feerate.GetFee(ws.m_vsize)) {
953 strprintf(
"%d < %d", ws.m_modified_fees, m_pool.m_opts.min_relay_feerate.GetFee(ws.m_vsize)));
958 if (!bypass_limits && !
args.m_package_feerates && !
CheckFeeRate(ws.m_vsize, ws.m_modified_fees, state))
return false;
960 ws.m_iters_conflicting = m_pool.GetIterSet(ws.m_conflicts);
967 if (ws.m_conflicts.size() == 1 &&
args.m_allow_carveouts) {
995 assert(ws.m_iters_conflicting.size() == 1);
1002 if (
auto ancestors{m_subpackage.m_changeset->CalculateMemPoolAncestors(ws.m_tx_handle, maybe_rbf_limits)}) {
1003 ws.m_ancestors = std::move(*ancestors);
1009 if (!
args.m_allow_carveouts) {
1034 if (
auto ancestors_retry{m_subpackage.m_changeset->CalculateMemPoolAncestors(ws.m_tx_handle, cpfp_carve_out_limits)}) {
1035 ws.m_ancestors = std::move(*ancestors_retry);
1044 if (!
args.m_bypass_limits) {
1045 if (
const auto err{
SingleTRUCChecks(ws.m_ptx, ws.m_ancestors, ws.m_conflicts, ws.m_vsize)}) {
1047 if (
args.m_allow_sibling_eviction && err->second !=
nullptr) {
1053 ws.m_conflicts.insert(err->second->GetHash());
1057 ws.m_iters_conflicting.insert(m_pool.GetIter(err->second->GetHash()).value());
1058 ws.m_sibling_eviction =
true;
1080 m_subpackage.m_rbf |= !ws.m_conflicts.empty();
1084bool MemPoolAccept::ReplacementChecks(Workspace& ws)
1090 const Txid& hash = ws.m_hash;
1093 CFeeRate newFeeRate(ws.m_modified_fees, ws.m_vsize);
1107 strprintf(
"insufficient fee%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1115 strprintf(
"too many potential replacements%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1120 Assume(!ws.m_sibling_eviction);
1122 strprintf(
"replacement-adds-unconfirmed%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1128 m_subpackage.m_conflicting_fees += it->GetModifiedFee();
1129 m_subpackage.m_conflicting_size += it->GetTxSize();
1131 if (
const auto err_string{
PaysForRBF(m_subpackage.m_conflicting_fees, ws.m_modified_fees, ws.m_vsize,
1132 m_pool.m_opts.incremental_relay_feerate, hash)}) {
1135 strprintf(
"insufficient fee%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1139 for (
auto it : all_conflicts) {
1140 m_subpackage.m_changeset->StageRemoval(it);
1145bool MemPoolAccept::PackageMempoolChecks(
const std::vector<CTransactionRef>& txns,
1146 std::vector<Workspace>& workspaces,
1147 const int64_t total_vsize,
1154 assert(std::all_of(txns.cbegin(), txns.cend(), [
this](
const auto& tx) { return !m_pool.exists(tx->GetHash()); }));
1156 assert(txns.size() == workspaces.size());
1158 auto result = m_pool.CheckPackageLimits(txns, total_vsize);
1165 if (!m_subpackage.m_rbf)
return true;
1176 for (
const auto& ws : workspaces) {
1177 if (!ws.m_ancestors.empty()) {
1184 for (Workspace& ws : workspaces) {
1186 direct_conflict_iters.merge(ws.m_iters_conflicting);
1189 const auto& parent_ws = workspaces[0];
1190 const auto& child_ws = workspaces[1];
1198 "package RBF failed: too many potential replacements", *err_string);
1203 m_subpackage.m_changeset->StageRemoval(it);
1204 m_subpackage.m_conflicting_fees += it->GetModifiedFee();
1205 m_subpackage.m_conflicting_size += it->GetTxSize();
1209 const Txid& child_hash = child_ws.m_ptx->GetHash();
1210 if (
const auto err_string{
PaysForRBF(m_subpackage.m_conflicting_fees,
1211 m_subpackage.m_total_modified_fees,
1212 m_subpackage.m_total_vsize,
1213 m_pool.m_opts.incremental_relay_feerate, child_hash)}) {
1215 "package RBF failed: insufficient anti-DoS fees", *err_string);
1220 const CFeeRate parent_feerate(parent_ws.m_modified_fees, parent_ws.m_vsize);
1221 const CFeeRate package_feerate(m_subpackage.m_total_modified_fees, m_subpackage.m_total_vsize);
1222 if (package_feerate <= parent_feerate) {
1224 "package RBF failed: package feerate is less than or equal to parent feerate",
1225 strprintf(
"package feerate %s <= parent feerate is %s", package_feerate.ToString(), parent_feerate.ToString()));
1232 "package RBF failed: " + err_tup.value().second,
"");
1235 LogDebug(
BCLog::TXPACKAGES,
"package RBF checks passed: parent %s (wtxid=%s), child %s (wtxid=%s), package hash (%s)\n",
1236 txns.front()->GetHash().ToString(), txns.front()->GetWitnessHash().ToString(),
1237 txns.back()->GetHash().ToString(), txns.back()->GetWitnessHash().ToString(),
1244bool MemPoolAccept::PolicyScriptChecks(
const ATMPArgs&
args, Workspace& ws)
1255 if (!
CheckInputScripts(tx, state, m_view, scriptVerifyFlags,
true,
false, ws.m_precomputed_txdata, GetValidationCache())) {
1267bool MemPoolAccept::ConsensusScriptChecks(
const ATMPArgs&
args, Workspace& ws)
1272 const Txid& hash = ws.m_hash;
1292 ws.m_precomputed_txdata, m_active_chainstate.CoinsTip(), GetValidationCache())) {
1293 LogPrintf(
"BUG! PLEASE REPORT THIS! CheckInputScripts failed against latest-block but not STANDARD flags %s, %s\n", hash.
ToString(), state.
ToString());
1300void MemPoolAccept::FinalizeSubpackage(
const ATMPArgs&
args)
1305 if (!m_subpackage.m_changeset->GetRemovals().empty())
Assume(
args.m_allow_replacement);
1309 std::string log_string =
strprintf(
"replacing mempool tx %s (wtxid=%s, fees=%s, vsize=%s). ",
1310 it->GetTx().GetHash().ToString(),
1311 it->GetTx().GetWitnessHash().ToString(),
1314 FeeFrac feerate{m_subpackage.m_total_modified_fees, int32_t(m_subpackage.m_total_vsize)};
1316 const bool replaced_with_tx{m_subpackage.m_changeset->GetTxCount() == 1};
1317 if (replaced_with_tx) {
1318 const CTransaction& tx = m_subpackage.m_changeset->GetAddedTxn(0);
1320 log_string +=
strprintf(
"New tx %s (wtxid=%s, fees=%s, vsize=%s)",
1326 tx_or_package_hash =
GetPackageHash(m_subpackage.m_changeset->GetAddedTxns());
1327 log_string +=
strprintf(
"New package %s with %lu txs, fees=%s, vsize=%s",
1328 tx_or_package_hash.ToString(),
1329 m_subpackage.m_changeset->GetTxCount(),
1336 it->GetTx().GetHash().data(),
1339 std::chrono::duration_cast<std::chrono::duration<std::uint64_t>>(it->GetTime()).count(),
1340 tx_or_package_hash.data(),
1345 m_subpackage.m_replaced_transactions.push_back(it->GetSharedTx());
1347 m_subpackage.m_changeset->Apply();
1348 m_subpackage.m_changeset.reset();
1351bool MemPoolAccept::SubmitPackage(
const ATMPArgs&
args, std::vector<Workspace>& workspaces,
1353 std::map<Wtxid, MempoolAcceptResult>& results)
1359 assert(std::all_of(workspaces.cbegin(), workspaces.cend(), [
this](
const auto& ws) { return !m_pool.exists(ws.m_ptx->GetHash()); }));
1361 bool all_submitted =
true;
1362 FinalizeSubpackage(
args);
1367 for (Workspace& ws : workspaces) {
1368 if (!ConsensusScriptChecks(
args, ws)) {
1372 all_submitted =
false;
1374 strprintf(
"BUG! PolicyScriptChecks succeeded but ConsensusScriptChecks failed: %s",
1375 ws.m_ptx->GetHash().ToString()));
1377 if (!m_subpackage.m_changeset) m_subpackage.m_changeset = m_pool.GetChangeSet();
1378 m_subpackage.m_changeset->StageRemoval(m_pool.GetIter(ws.m_ptx->GetHash()).value());
1381 if (!all_submitted) {
1382 Assume(m_subpackage.m_changeset);
1386 m_subpackage.m_changeset->Apply();
1387 m_subpackage.m_changeset.reset();
1391 std::vector<Wtxid> all_package_wtxids;
1392 all_package_wtxids.reserve(workspaces.size());
1393 std::transform(workspaces.cbegin(), workspaces.cend(), std::back_inserter(all_package_wtxids),
1394 [](
const auto& ws) { return ws.m_ptx->GetWitnessHash(); });
1396 if (!m_subpackage.m_replaced_transactions.empty()) {
1397 LogDebug(
BCLog::MEMPOOL,
"replaced %u mempool transactions with %u new one(s) for %s additional fees, %d delta bytes\n",
1398 m_subpackage.m_replaced_transactions.size(), workspaces.size(),
1399 m_subpackage.m_total_modified_fees - m_subpackage.m_conflicting_fees,
1400 m_subpackage.m_total_vsize -
static_cast<int>(m_subpackage.m_conflicting_size));
1404 for (Workspace& ws : workspaces) {
1405 auto iter = m_pool.GetIter(ws.m_ptx->GetHash());
1406 Assume(iter.has_value());
1407 const auto effective_feerate =
args.m_package_feerates ? ws.m_package_feerate :
1408 CFeeRate{ws.m_modified_fees,
static_cast<int32_t
>(ws.m_vsize)};
1409 const auto effective_feerate_wtxids =
args.m_package_feerates ? all_package_wtxids :
1410 std::vector<Wtxid>{ws.m_ptx->GetWitnessHash()};
1411 results.emplace(ws.m_ptx->GetWitnessHash(),
1413 ws.m_base_fees, effective_feerate, effective_feerate_wtxids));
1414 if (!m_pool.m_opts.signals)
continue;
1417 ws.m_vsize, (*iter)->GetHeight(),
1418 args.m_bypass_limits,
args.m_package_submission,
1420 m_pool.HasNoInputsOf(tx));
1421 m_pool.m_opts.signals->TransactionAddedToMempool(tx_info, m_pool.GetAndIncrementSequence());
1423 return all_submitted;
1432 const std::vector<Wtxid> single_wtxid{ws.m_ptx->GetWitnessHash()};
1434 if (!PreChecks(
args, ws)) {
1442 m_subpackage.m_total_vsize = ws.m_vsize;
1443 m_subpackage.m_total_modified_fees = ws.m_modified_fees;
1446 if (
args.m_client_maxfeerate &&
CFeeRate(ws.m_modified_fees, ws.m_vsize) >
args.m_client_maxfeerate.value()) {
1451 if (m_pool.m_opts.require_standard) {
1453 if (!
CheckEphemeralSpends({ptx}, m_pool.m_opts.dust_relay_feerate, m_pool, ws.m_state, dummy_wtxid)) {
1458 if (m_subpackage.m_rbf && !ReplacementChecks(ws)) {
1472 const CFeeRate effective_feerate{ws.m_modified_fees,
static_cast<int32_t
>(ws.m_vsize)};
1474 if (
args.m_test_accept) {
1476 ws.m_base_fees, effective_feerate, single_wtxid);
1479 FinalizeSubpackage(
args);
1482 if (!
args.m_package_submission && !
args.m_bypass_limits) {
1486 CleanupTemporaryCoins();
1488 if (!m_pool.exists(ws.m_hash)) {
1495 if (m_pool.m_opts.signals) {
1497 auto iter = m_pool.GetIter(tx.
GetHash());
1498 Assume(iter.has_value());
1500 ws.m_vsize, (*iter)->GetHeight(),
1501 args.m_bypass_limits,
args.m_package_submission,
1503 m_pool.HasNoInputsOf(tx));
1504 m_pool.m_opts.signals->TransactionAddedToMempool(tx_info, m_pool.GetAndIncrementSequence());
1507 if (!m_subpackage.m_replaced_transactions.empty()) {
1508 LogDebug(
BCLog::MEMPOOL,
"replaced %u mempool transactions with 1 new transaction for %s additional fees, %d delta bytes\n",
1509 m_subpackage.m_replaced_transactions.size(),
1510 ws.m_modified_fees - m_subpackage.m_conflicting_fees,
1511 ws.m_vsize -
static_cast<int>(m_subpackage.m_conflicting_size));
1515 effective_feerate, single_wtxid);
1526 std::vector<Workspace> workspaces{};
1527 workspaces.reserve(txns.size());
1528 std::transform(txns.cbegin(), txns.cend(), std::back_inserter(workspaces),
1529 [](
const auto& tx) { return Workspace(tx); });
1530 std::map<Wtxid, MempoolAcceptResult> results;
1535 for (Workspace& ws : workspaces) {
1536 if (!PreChecks(
args, ws)) {
1545 if (
args.m_client_maxfeerate &&
CFeeRate(ws.m_modified_fees, ws.m_vsize) >
args.m_client_maxfeerate.value()) {
1563 m_viewmempool.PackageAddTransaction(ws.m_ptx);
1568 for (Workspace& ws : workspaces) {
1584 m_subpackage.m_total_vsize = std::accumulate(workspaces.cbegin(), workspaces.cend(), int64_t{0},
1585 [](int64_t
sum,
auto& ws) { return sum + ws.m_vsize; });
1586 m_subpackage.m_total_modified_fees = std::accumulate(workspaces.cbegin(), workspaces.cend(),
CAmount{0},
1587 [](
CAmount sum,
auto& ws) { return sum + ws.m_modified_fees; });
1588 const CFeeRate package_feerate(m_subpackage.m_total_modified_fees, m_subpackage.m_total_vsize);
1589 std::vector<Wtxid> all_package_wtxids;
1590 all_package_wtxids.reserve(workspaces.size());
1591 std::transform(workspaces.cbegin(), workspaces.cend(), std::back_inserter(all_package_wtxids),
1592 [](
const auto& ws) { return ws.m_ptx->GetWitnessHash(); });
1594 if (
args.m_package_feerates &&
1595 !
CheckFeeRate(m_subpackage.m_total_vsize, m_subpackage.m_total_modified_fees, placeholder_state)) {
1603 if (txns.size() > 1 && !PackageMempoolChecks(txns, workspaces, m_subpackage.m_total_vsize, package_state)) {
1608 if (m_pool.m_opts.require_standard) {
1611 if (!
CheckEphemeralSpends(txns, m_pool.m_opts.dust_relay_feerate, m_pool, child_state, child_wtxid)) {
1618 for (Workspace& ws : workspaces) {
1619 ws.m_package_feerate = package_feerate;
1620 if (!PolicyScriptChecks(
args, ws)) {
1626 if (
args.m_test_accept) {
1627 const auto effective_feerate =
args.m_package_feerates ? ws.m_package_feerate :
1628 CFeeRate{ws.m_modified_fees,
static_cast<int32_t
>(ws.m_vsize)};
1629 const auto effective_feerate_wtxids =
args.m_package_feerates ? all_package_wtxids :
1630 std::vector<Wtxid>{ws.m_ptx->GetWitnessHash()};
1631 results.emplace(ws.m_ptx->GetWitnessHash(),
1633 ws.m_vsize, ws.m_base_fees, effective_feerate,
1634 effective_feerate_wtxids));
1640 if (!SubmitPackage(
args, workspaces, package_state, results)) {
1648void MemPoolAccept::CleanupTemporaryCoins()
1669 for (
const auto& outpoint : m_viewmempool.GetNonBaseCoins()) {
1672 m_view.Uncache(outpoint);
1675 m_viewmempool.Reset();
1683 if (subpackage.size() > 1) {
1684 return AcceptMultipleTransactions(subpackage,
args);
1686 const auto& tx = subpackage.front();
1687 ATMPArgs single_args = ATMPArgs::SingleInPackageAccept(
args);
1688 const auto single_res = AcceptSingleTransaction(tx, single_args);
1699 ClearSubPackageState();
1706 Assert(!package.empty());
1732 std::map<Wtxid, MempoolAcceptResult> results_final;
1736 std::map<Wtxid, MempoolAcceptResult> individual_results_nonfinal;
1738 bool quit_early{
false};
1739 std::vector<CTransactionRef> txns_package_eval;
1740 for (
const auto& tx : package) {
1742 const auto& txid = tx->
GetHash();
1746 if (m_pool.exists(wtxid)) {
1756 const auto& entry{*
Assert(m_pool.GetEntry(txid))};
1758 }
else if (m_pool.exists(txid)) {
1766 const auto& entry{*
Assert(m_pool.GetEntry(txid))};
1772 const auto single_package_res = AcceptSubPackage({tx},
args);
1773 const auto& single_res = single_package_res.m_tx_results.at(wtxid);
1777 assert(m_pool.exists(wtxid));
1778 results_final.emplace(wtxid, single_res);
1779 }
else if (package.size() == 1 ||
1793 individual_results_nonfinal.emplace(wtxid, single_res);
1795 individual_results_nonfinal.emplace(wtxid, single_res);
1796 txns_package_eval.push_back(tx);
1801 auto multi_submission_result = quit_early || txns_package_eval.empty() ?
PackageMempoolAcceptResult(package_state_quit_early, {}) :
1802 AcceptSubPackage(txns_package_eval,
args);
1808 ClearSubPackageState();
1815 for (
const auto& tx : package) {
1817 if (multi_submission_result.m_tx_results.count(wtxid) > 0) {
1819 Assume(results_final.count(wtxid) == 0);
1822 const auto& txresult = multi_submission_result.m_tx_results.at(wtxid);
1829 results_final.emplace(wtxid, txresult);
1831 }
else if (
const auto it{results_final.find(wtxid)}; it != results_final.end()) {
1835 Assume(individual_results_nonfinal.count(wtxid) == 0);
1837 if (!m_pool.exists(tx->
GetHash())) {
1842 results_final.erase(wtxid);
1845 }
else if (
const auto it{individual_results_nonfinal.find(wtxid)}; it != individual_results_nonfinal.end()) {
1848 results_final.emplace(wtxid, it->second);
1851 Assume(results_final.size() == package.size());
1858 int64_t accept_time,
bool bypass_limits,
bool test_accept)
1865 std::vector<COutPoint> coins_to_uncache;
1866 auto args = MemPoolAccept::ATMPArgs::SingleAccept(chainparams, accept_time, bypass_limits, coins_to_uncache, test_accept);
1874 for (
const COutPoint& hashTx : coins_to_uncache)
1877 tx->GetHash().data(),
1888 const Package& package,
bool test_accept,
const std::optional<CFeeRate>& client_maxfeerate)
1891 assert(!package.empty());
1892 assert(std::all_of(package.cbegin(), package.cend(), [](
const auto& tx){return tx != nullptr;}));
1894 std::vector<COutPoint> coins_to_uncache;
1899 auto args = MemPoolAccept::ATMPArgs::PackageTestAccept(chainparams,
GetTime(), coins_to_uncache);
1900 return MemPoolAccept(pool, active_chainstate).AcceptMultipleTransactions(package,
args);
1902 auto args = MemPoolAccept::ATMPArgs::PackageChildWithParents(chainparams,
GetTime(), coins_to_uncache, client_maxfeerate);
1903 return MemPoolAccept(pool, active_chainstate).AcceptPackage(package,
args);
1908 if (test_accept || result.m_state.IsInvalid()) {
1909 for (
const COutPoint& hashTx : coins_to_uncache) {
1928 nSubsidy >>= halvings;
1933 : m_dbview{
std::move(db_params),
std::move(options)},
1934 m_catcherview(&m_dbview) {}
1936void CoinsViews::InitCache()
1939 m_cacheview = std::make_unique<CCoinsViewCache>(&m_catcherview);
1946 std::optional<uint256> from_snapshot_blockhash)
1947 : m_mempool(mempool),
1948 m_blockman(blockman),
1949 m_chainman(chainman),
1950 m_from_snapshot_blockhash(from_snapshot_blockhash) {}
1952const CBlockIndex* Chainstate::SnapshotBase()
const
1956 return m_cached_snapshot_base;
1960 size_t cache_size_bytes,
1963 fs::path leveldb_name)
1972 .cache_bytes = cache_size_bytes,
1973 .memory_only = in_memory,
1974 .wipe_data = should_wipe,
1982void Chainstate::InitCoinsCache(
size_t cache_size_bytes)
2008 if (chain.Tip() ==
nullptr) {
2017 LogInfo(
"Leaving InitialBlockDownload (latching to false)");
2034 LogPrintf(
"%s: Warning: Found invalid chain at least ~6 blocks longer than our best chain.\nChain state database corruption likely.\n", __func__);
2037 _(
"Warning: We do not appear to fully agree with our peers! You may need to upgrade, or other nodes may need to upgrade."));
2050 SetBlockFailureFlags(pindexNew);
2055 LogPrintf(
"%s: invalid block=%s height=%d log2_work=%f date=%s\n", __func__,
2060 LogPrintf(
"%s: current best=%s height=%d log2_work=%f date=%s\n", __func__,
2098 if (
VerifyScript(scriptSig,
m_tx_out.
scriptPubKey, witness,
m_flags,
CachingTransactionSignatureChecker(
ptxTo,
nIn,
m_tx_out.
nValue,
cacheStore, *
m_signature_cache, *
txdata), &error)) {
2099 return std::nullopt;
2102 return std::make_pair(error, std::move(debug_str));
2107 : m_signature_cache{signature_cache_bytes}
2118 LogInfo(
"Using %zu MiB out of %zu MiB requested for script execution cache, able to store %zu elements",
2119 approx_size_bytes >> 20, script_execution_cache_bytes >> 20, num_elems);
2145 std::vector<CScriptCheck>* pvChecks)
2150 pvChecks->reserve(tx.
vin.size());
2167 std::vector<CTxOut> spent_outputs;
2168 spent_outputs.reserve(tx.
vin.size());
2170 for (
const auto& txin : tx.
vin) {
2174 spent_outputs.emplace_back(coin.
out);
2176 txdata.
Init(tx, std::move(spent_outputs));
2180 for (
unsigned int i = 0; i < tx.
vin.size(); i++) {
2191 pvChecks->emplace_back(std::move(check));
2192 }
else if (
auto result = check(); result.has_value()) {
2207 if (cacheFullScriptStore && !pvChecks) {
2235 if (undo.nHeight == 0) {
2241 undo.nHeight = alternate.
nHeight;
2266 LogError(
"DisconnectBlock(): failure reading undo data\n");
2270 if (blockUndo.
vtxundo.size() + 1 != block.
vtx.size()) {
2271 LogError(
"DisconnectBlock(): block and undo data inconsistent\n");
2281 bool fEnforceBIP30 = !((pindex->
nHeight==91722 && pindex->
GetBlockHash() ==
uint256{
"00000000000271a2dc26e7667f8419f2e15416dc6955e5a6c6cdf3f2574dd08e"}) ||
2282 (pindex->
nHeight==91812 && pindex->
GetBlockHash() ==
uint256{
"00000000000af0aed4792b1acee3d966af36cf5def14935db8de83d6f9306f2f"}));
2285 for (
int i = block.
vtx.size() - 1; i >= 0; i--) {
2289 bool is_bip30_exception = (is_coinbase && !fEnforceBIP30);
2293 for (
size_t o = 0; o < tx.
vout.size(); o++) {
2294 if (!tx.
vout[o].scriptPubKey.IsUnspendable()) {
2299 if (!is_bip30_exception) {
2310 LogError(
"DisconnectBlock(): transaction and undo data inconsistent\n");
2313 for (
unsigned int j = tx.
vin.size(); j > 0;) {
2384 const auto time_start{SteadyClock::now()};
2400 if (!
CheckBlock(block, state, params.GetConsensus(), !fJustCheck, !fJustCheck)) {
2412 uint256 hashPrevBlock = pindex->
pprev ==
nullptr ?
uint256() : pindex->pprev->GetBlockHash();
2419 if (block_hash == params.GetConsensus().hashGenesisBlock) {
2425 bool fScriptChecks =
true;
2434 if (it->second.GetAncestor(pindex->
nHeight) == pindex &&
2456 const auto time_1{SteadyClock::now()};
2457 m_chainman.time_check += time_1 - time_start;
2459 Ticks<MillisecondsDouble>(time_1 - time_start),
2501 static constexpr int BIP34_IMPLIES_BIP30_LIMIT = 1983702;
2533 fEnforceBIP30 = fEnforceBIP30 && (!pindexBIP34height || !(pindexBIP34height->
GetBlockHash() == params.GetConsensus().BIP34Hash));
2538 if (fEnforceBIP30 || pindex->
nHeight >= BIP34_IMPLIES_BIP30_LIMIT) {
2539 for (
const auto& tx : block.
vtx) {
2540 for (
size_t o = 0; o < tx->
vout.size(); o++) {
2543 "tried to overwrite transaction");
2550 int nLockTimeFlags = 0;
2558 const auto time_2{SteadyClock::now()};
2561 Ticks<MillisecondsDouble>(time_2 - time_1),
2566 LogInfo(
"%s signature validations at block #%d (%s).", fScriptChecks ?
"Enabling" :
"Disabling", pindex->
nHeight, block_hash.ToString());
2577 std::optional<CCheckQueueControl<CScriptCheck>> control;
2580 std::vector<PrecomputedTransactionData> txsdata(block.
vtx.size());
2582 std::vector<int> prevheights;
2585 int64_t nSigOpsCost = 0;
2586 blockundo.
vtxundo.reserve(block.
vtx.size() - 1);
2587 for (
unsigned int i = 0; i < block.
vtx.size(); i++)
2592 nInputs += tx.
vin.size();
2608 "accumulated fee in the block out of range");
2615 prevheights.resize(tx.
vin.size());
2616 for (
size_t j = 0; j < tx.
vin.size(); j++) {
2620 if (!
SequenceLocks(tx, nLockTimeFlags, prevheights, *pindex)) {
2639 bool fCacheResults = fJustCheck;
2645 std::vector<CScriptCheck> vChecks;
2647 if (tx_ok) control->Add(std::move(vChecks));
2661 blockundo.
vtxundo.emplace_back();
2665 const auto time_3{SteadyClock::now()};
2667 LogDebug(
BCLog::BENCH,
" - Connect %u transactions: %.2fms (%.3fms/tx, %.3fms/txin) [%.2fs (%.2fms/blk)]\n", (
unsigned)block.
vtx.size(),
2668 Ticks<MillisecondsDouble>(time_3 - time_2), Ticks<MillisecondsDouble>(time_3 - time_2) / block.
vtx.size(),
2669 nInputs <= 1 ? 0 : Ticks<MillisecondsDouble>(time_3 - time_2) / (nInputs - 1),
2670 Ticks<SecondsDouble>(
m_chainman.time_connect),
2674 if (block.
vtx[0]->GetValueOut() > blockReward && state.
IsValid()) {
2676 strprintf(
"coinbase pays too much (actual=%d vs limit=%d)", block.
vtx[0]->GetValueOut(), blockReward));
2679 auto parallel_result = control->Complete();
2680 if (parallel_result.has_value() && state.
IsValid()) {
2688 const auto time_4{SteadyClock::now()};
2690 LogDebug(
BCLog::BENCH,
" - Verify %u txins: %.2fms (%.3fms/txin) [%.2fs (%.2fms/blk)]\n", nInputs - 1,
2691 Ticks<MillisecondsDouble>(time_4 - time_2),
2692 nInputs <= 1 ? 0 : Ticks<MillisecondsDouble>(time_4 - time_2) / (nInputs - 1),
2693 Ticks<SecondsDouble>(
m_chainman.time_verify),
2700 if (!
m_blockman.WriteBlockUndo(blockundo, state, *pindex)) {
2704 const auto time_5{SteadyClock::now()};
2707 Ticks<MillisecondsDouble>(time_5 - time_4),
2719 const auto time_6{SteadyClock::now()};
2722 Ticks<MillisecondsDouble>(time_6 - time_5),
2732 Ticks<std::chrono::nanoseconds>(time_5 - time_start)
2741 return this->GetCoinsCacheSizeState(
2747 size_t max_coins_cache_size_bytes,
2748 size_t max_mempool_size_bytes)
2753 int64_t nTotalSpace =
2754 max_coins_cache_size_bytes + std::max<int64_t>(int64_t(max_mempool_size_bytes) - nMempoolUsage, 0);
2756 if (cacheSize > nTotalSpace) {
2757 LogPrintf(
"Cache size (%s) exceeds total space (%s)\n", cacheSize, nTotalSpace);
2768 int nManualPruneHeight)
2772 std::set<int> setFilesToPrune;
2773 bool full_flush_completed =
false;
2780 bool fFlushForPrune =
false;
2788 std::optional<std::string> limiting_lock;
2790 for (
const auto& prune_lock :
m_blockman.m_prune_locks) {
2791 if (prune_lock.second.height_first == std::numeric_limits<int>::max())
continue;
2794 last_prune = std::max(1, std::min(last_prune, lock_height));
2795 if (last_prune == lock_height) {
2796 limiting_lock = prune_lock.first;
2800 if (limiting_lock) {
2801 LogDebug(
BCLog::PRUNE,
"%s limited pruning to height %d\n", limiting_lock.value(), last_prune);
2804 if (nManualPruneHeight > 0) {
2809 std::min(last_prune, nManualPruneHeight),
2817 if (!setFilesToPrune.empty()) {
2818 fFlushForPrune =
true;
2820 m_blockman.m_block_tree_db->WriteFlag(
"prunedblockfiles",
true);
2833 bool should_write = (mode ==
FlushStateMode::ALWAYS) || fCacheLarge || fCacheCritical || fPeriodicWrite || fFlushForPrune;
2836 LogDebug(
BCLog::COINDB,
"Writing chainstate to disk: flush mode=%s, prune=%d, large=%d, critical=%d, periodic=%d",
2837 FlushStateModeNames[
size_t(mode)], fFlushForPrune, fCacheLarge, fCacheCritical, fPeriodicWrite);
2863 if (fFlushForPrune) {
2869 if (!
CoinsTip().GetBestBlock().IsNull()) {
2870 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);
2887 full_flush_completed =
true;
2889 int64_t{Ticks<std::chrono::microseconds>(
NodeClock::now() - nNow)},
2891 (uint64_t)coins_count,
2892 (uint64_t)coins_mem_usage,
2893 (
bool)fFlushForPrune);
2897 if (should_write ||
m_next_write == NodeClock::time_point::max()) {
2906 }
catch (
const std::runtime_error& e) {
2933 const std::string& func_name,
2934 const std::string&
prefix,
2946 chainman.GuessVerificationProgress(tip),
2949 !warning_messages.empty() ?
strprintf(
" warning='%s'", warning_messages) :
"");
2952void Chainstate::UpdateTip(
const CBlockIndex* pindexNew)
2955 const auto& coins_tip = this->
CoinsTip();
2961 constexpr int BACKGROUND_LOG_INTERVAL = 2000;
2962 if (pindexNew->
nHeight % BACKGROUND_LOG_INTERVAL == 0) {
2973 std::vector<bilingual_str> warning_messages;
2976 for (
auto [bit, active] : bits) {
2981 warning_messages.push_back(warning);
3008 std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
3011 LogError(
"DisconnectTip(): Failed to read block\n");
3015 const auto time_start{SteadyClock::now()};
3019 if (DisconnectBlock(block, pindexDelete, view) !=
DISCONNECT_OK) {
3023 bool flushed = view.
Flush();
3027 Ticks<MillisecondsDouble>(SteadyClock::now() - time_start));
3031 const int max_height_first{pindexDelete->
nHeight - 1};
3032 for (
auto& prune_lock :
m_blockman.m_prune_locks) {
3033 if (prune_lock.second.height_first <= max_height_first)
continue;
3035 prune_lock.second.height_first = max_height_first;
3036 LogDebug(
BCLog::PRUNE,
"%s prune lock moved back to %d\n", prune_lock.first, max_height_first);
3055 UpdateTip(pindexDelete->
pprev);
3113 std::shared_ptr<const CBlock> block_to_connect,
3122 const auto time_1{SteadyClock::now()};
3123 if (!block_to_connect) {
3124 std::shared_ptr<CBlock> pblockNew = std::make_shared<CBlock>();
3128 block_to_connect = std::move(pblockNew);
3133 const auto time_2{SteadyClock::now()};
3134 SteadyClock::time_point time_3;
3138 Ticks<MillisecondsDouble>(time_2 - time_1));
3141 bool rv =
ConnectBlock(*block_to_connect, state, pindexNew, view);
3151 time_3 = SteadyClock::now();
3152 m_chainman.time_connect_total += time_3 - time_2;
3155 Ticks<MillisecondsDouble>(time_3 - time_2),
3156 Ticks<SecondsDouble>(
m_chainman.time_connect_total),
3158 bool flushed = view.
Flush();
3161 const auto time_4{SteadyClock::now()};
3164 Ticks<MillisecondsDouble>(time_4 - time_3),
3171 const auto time_5{SteadyClock::now()};
3172 m_chainman.time_chainstate += time_5 - time_4;
3174 Ticks<MillisecondsDouble>(time_5 - time_4),
3175 Ticks<SecondsDouble>(
m_chainman.time_chainstate),
3184 UpdateTip(pindexNew);
3186 const auto time_6{SteadyClock::now()};
3187 m_chainman.time_post_connect += time_6 - time_5;
3190 Ticks<MillisecondsDouble>(time_6 - time_5),
3191 Ticks<SecondsDouble>(
m_chainman.time_post_connect),
3194 Ticks<MillisecondsDouble>(time_6 - time_1),
3203 m_chainman.MaybeCompleteSnapshotValidation();
3206 connectTrace.
BlockConnected(pindexNew, std::move(block_to_connect));
3231 bool fInvalidAncestor =
false;
3241 if (fFailedChain || fMissingData) {
3248 while (pindexTest != pindexFailed) {
3252 }
else if (fMissingData) {
3257 std::make_pair(pindexFailed->
pprev, pindexFailed));
3260 pindexFailed = pindexFailed->
pprev;
3263 fInvalidAncestor =
true;
3266 pindexTest = pindexTest->
pprev;
3268 if (!fInvalidAncestor)
3300 bool fBlocksDisconnected =
false;
3314 fBlocksDisconnected =
true;
3318 std::vector<CBlockIndex*> vpindexToConnect;
3319 bool fContinue =
true;
3324 int nTargetHeight = std::min(
nHeight + 32, pindexMostWork->
nHeight);
3325 vpindexToConnect.clear();
3326 vpindexToConnect.reserve(nTargetHeight -
nHeight);
3329 vpindexToConnect.push_back(pindexIter);
3330 pindexIter = pindexIter->
pprev;
3335 for (
CBlockIndex* pindexConnect : vpindexToConnect | std::views::reverse) {
3336 if (!
ConnectTip(state, pindexConnect, pindexConnect == pindexMostWork ? pblock : std::shared_ptr<const CBlock>(), connectTrace, disconnectpool)) {
3343 fInvalidFound =
true;
3364 if (fBlocksDisconnected) {
3385 bool fNotify =
false;
3386 bool fInitialBlockDownload =
false;
3390 pindexHeader = m_best_header;
3392 if (pindexHeader != m_last_notified_header) {
3395 m_last_notified_header = pindexHeader;
3408 if (signals.CallbacksPending() > 10) {
3409 signals.SyncWithValidationInterfaceQueue();
3413bool Chainstate::ActivateBestChain(
BlockValidationState& state, std::shared_ptr<const CBlock> pblock)
3432 LogPrintf(
"m_disabled is set - this chainstate should not be in operation. "
3433 "Please report this as a bug. %s\n", CLIENT_BUGREPORT);
3439 bool exited_ibd{
false};
3456 bool blocks_connected =
false;
3462 if (pindexMostWork ==
nullptr) {
3467 if (pindexMostWork ==
nullptr || pindexMostWork ==
m_chain.
Tip()) {
3471 bool fInvalidFound =
false;
3472 std::shared_ptr<const CBlock> nullBlockPtr;
3477 if (!
ActivateBestChainStep(state, pindexMostWork, pblock && pblock->GetHash() == pindexMostWork->
GetBlockHash() ? pblock : nullBlockPtr, fInvalidFound, connectTrace)) {
3481 blocks_connected =
true;
3483 if (fInvalidFound) {
3485 pindexMostWork =
nullptr;
3490 assert(trace.pblock && trace.pindex);
3505 if (!blocks_connected)
return true;
3510 if (was_in_ibd && !still_in_ibd) {
3570 }
while (pindexNewTip != pindexMostWork);
3610 return ActivateBestChain(state, std::shared_ptr<const CBlock>());
3620 if (pindex->
nHeight == 0)
return false;
3623 bool pindex_was_in_chain =
false;
3624 int disconnected = 0;
3638 std::multimap<const arith_uint256, CBlockIndex*> highpow_outofchain_headers;
3642 for (
auto& entry :
m_blockman.m_block_index) {
3652 highpow_outofchain_headers.insert({candidate->
nChainWork, candidate});
3669 pindex_was_in_chain =
true;
3682 if (!
ret)
return false;
3705 auto candidate_it = highpow_outofchain_headers.lower_bound(invalid_walk_tip->
pprev->
nChainWork);
3707 const bool best_header_needs_update{
m_chainman.m_best_header->GetAncestor(invalid_walk_tip->
nHeight) == invalid_walk_tip};
3708 if (best_header_needs_update) {
3713 while (candidate_it != highpow_outofchain_headers.end()) {
3717 candidate->nStatus &= ~BLOCK_FAILED_VALID;
3722 candidate_it = highpow_outofchain_headers.erase(candidate_it);
3732 if (best_header_needs_update &&
3741 to_mark_failed = invalid_walk_tip;
3767 for (
auto& [
_, block_index] :
m_blockman.m_block_index) {
3777 if (pindex_was_in_chain) {
3787 *to_mark_failed->
pprev,
3799void Chainstate::SetBlockFailureFlags(
CBlockIndex* invalid_block)
3803 for (
auto& [
_, block_index] :
m_blockman.m_block_index) {
3804 if (invalid_block != &block_index && block_index.GetAncestor(invalid_block->
nHeight) == invalid_block) {
3805 block_index.nStatus = (block_index.nStatus & ~BLOCK_FAILED_VALID) |
BLOCK_FAILED_CHILD;
3817 for (
auto& [
_, block_index] :
m_blockman.m_block_index) {
3819 block_index.nStatus &= ~BLOCK_FAILED_MASK;
3824 if (&block_index ==
m_chainman.m_best_invalid) {
3842 if (is_active_chainstate) {
3846 }
else if (!m_disabled) {
3851 if (snapshot_base->GetAncestor(pindex->
nHeight) == pindex) {
3861 pindexNew->
nTx = block.
vtx.size();
3867 auto prev_tx_sum = [](
CBlockIndex& block) {
return block.nTx + (block.pprev ? block.pprev->m_chain_tx_count : 0); };
3869 pindexNew == GetSnapshotBaseBlock())) {
3870 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",
3874 pindexNew->nFile = pos.
nFile;
3875 pindexNew->nDataPos = pos.
nPos;
3876 pindexNew->nUndoPos = 0;
3886 std::deque<CBlockIndex*> queue;
3887 queue.push_back(pindexNew);
3890 while (!queue.empty()) {
3898 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",
3904 c->TryAddBlockIndexCandidate(pindex);
3906 std::pair<std::multimap<CBlockIndex*, CBlockIndex*>::iterator, std::multimap<CBlockIndex*, CBlockIndex*>::iterator> range =
m_blockman.
m_blocks_unlinked.equal_range(pindex);
3907 while (range.first != range.second) {
3908 std::multimap<CBlockIndex*, CBlockIndex*>::iterator it = range.first;
3909 queue.push_back(it->second);
3940 "hashMerkleRoot mismatch");
3949 "bad-txns-duplicate",
3950 "duplicate transaction");
3965 if (expect_witness_commitment) {
3970 assert(!block.
vtx.empty() && !block.
vtx[0]->vin.empty());
3971 const auto& witness_stack{block.
vtx[0]->vin[0].scriptWitness.stack};
3973 if (witness_stack.size() != 1 || witness_stack[0].size() != 32) {
3976 "bad-witness-nonce-size",
3977 strprintf(
"%s : invalid witness reserved value size", __func__));
3986 if (memcmp(hash_witness.
begin(), &block.
vtx[0]->vout[commitpos].scriptPubKey[6], 32)) {
3989 "bad-witness-merkle-match",
3990 strprintf(
"%s : witness merkle commitment mismatch", __func__));
3999 for (
const auto& tx : block.
vtx) {
4003 "unexpected-witness",
4004 strprintf(
"%s : unexpected witness data found", __func__));
4044 if (block.
vtx.empty() || !block.
vtx[0]->IsCoinBase())
4046 for (
unsigned int i = 1; i < block.
vtx.size(); i++)
4047 if (block.
vtx[i]->IsCoinBase())
4052 for (
const auto& tx : block.
vtx) {
4064 unsigned int nSigOps = 0;
4065 for (
const auto& tx : block.
vtx)
4072 if (fCheckPOW && fCheckMerkleRoot)
4081 static const std::vector<unsigned char>
nonce(32, 0x00);
4084 tx.
vin[0].scriptWitness.stack.resize(1);
4085 tx.
vin[0].scriptWitness.stack[0] =
nonce;
4092 std::vector<unsigned char> commitment;
4094 std::vector<unsigned char>
ret(32, 0x00);
4102 out.scriptPubKey[1] = 0x24;
4103 out.scriptPubKey[2] = 0xaa;
4104 out.scriptPubKey[3] = 0x21;
4105 out.scriptPubKey[4] = 0xa9;
4106 out.scriptPubKey[5] = 0xed;
4107 memcpy(&
out.scriptPubKey[6], witnessroot.
begin(), 32);
4108 commitment = std::vector<unsigned char>(
out.scriptPubKey.begin(),
out.scriptPubKey.end());
4119 return std::all_of(headers.cbegin(), headers.cend(),
4120 [&](
const auto& header) { return CheckProofOfWork(header.GetHash(), header.nBits, consensusParams);});
4131 if (block.
vtx.empty() || !block.
vtx[0]->IsCoinBase()) {
4138 return std::any_of(block.
vtx.begin(), block.
vtx.end(),
4139 [](
auto& tx) { return GetSerializeSize(TX_NO_WITNESS(tx)) == 64; });
4180 assert(pindexPrev !=
nullptr);
4181 const int nHeight = pindexPrev->nHeight + 1;
4189 if (block.
GetBlockTime() <= pindexPrev->GetMedianTimePast())
4228 const int nHeight = pindexPrev ==
nullptr ? 0 : pindexPrev->
nHeight + 1;
4231 bool enforce_locktime_median_time_past{
false};
4233 assert(pindexPrev !=
nullptr);
4234 enforce_locktime_median_time_past =
true;
4237 const int64_t nLockTimeCutoff{enforce_locktime_median_time_past ?
4242 for (
const auto& tx : block.
vtx) {
4252 if (block.
vtx[0]->vin[0].scriptSig.size() <
expect.size() ||
4253 !std::equal(
expect.begin(),
expect.end(), block.
vtx[0]->vin[0].scriptSig.begin())) {
4289 BlockMap::iterator miSelf{
m_blockman.m_block_index.find(hash)};
4291 if (miSelf !=
m_blockman.m_block_index.end()) {
4315 pindexPrev = &((*mi).second);
4325 if (!min_pow_checked) {
4360 blocks_left = std::max<int64_t>(0, blocks_left);
4361 const double progress{100.0 * last_accepted.nHeight / (last_accepted.nHeight + blocks_left)};
4362 LogInfo(
"Synchronizing blockheaders, height: %d (~%.2f%%)\n", last_accepted.nHeight, progress);
4380 if (now < m_last_presync_update + std::chrono::milliseconds{250})
return;
4381 m_last_presync_update = now;
4385 if (initial_download) {
4387 blocks_left = std::max<int64_t>(0, blocks_left);
4388 const double progress{100.0 * height / (height + blocks_left)};
4389 LogInfo(
"Pre-synchronizing blockheaders, height: %d (~%.2f%%)\n", height, progress);
4396 const CBlock& block = *pblock;
4398 if (fNewBlock) *fNewBlock =
false;
4402 CBlockIndex *&pindex = ppindex ? *ppindex : pindexDummy;
4404 bool accepted_header{
AcceptBlockHeader(block, state, &pindex, min_pow_checked)};
4407 if (!accepted_header)
4431 if (fAlreadyHave)
return true;
4433 if (pindex->
nTx != 0)
return true;
4434 if (!fHasMoreOrSameWork)
return true;
4435 if (fTooFarAhead)
return true;
4446 if (!
CheckBlock(block, state, params.GetConsensus()) ||
4462 if (fNewBlock) *fNewBlock =
true;
4470 if (blockPos.IsNull()) {
4471 state.
Error(
strprintf(
"%s: Failed to find position to write new block to disk", __func__));
4476 }
catch (
const std::runtime_error& e) {
4500 if (new_block) *new_block =
false;
4515 ret =
AcceptBlock(block, state, &pindex, force_processing,
nullptr, new_block, min_pow_checked);
4530 LogError(
"%s: ActivateBestChain failed (%s)\n", __func__, state.
ToString());
4536 if (bg_chain && !bg_chain->ActivateBestChain(bg_state, block)) {
4537 LogError(
"%s: [background] ActivateBestChain failed (%s)\n", __func__, bg_state.
ToString());
4562 const bool check_pow,
4563 const bool check_merkle_root)
4574 state.
Invalid({},
"inconclusive-not-best-prevblk");
4615 index_dummy.pprev = tip;
4617 index_dummy.phashBlock = &block_hash;
4621 if(!chainstate.
ConnectBlock(block, state, &index_dummy, view_dummy,
true)) {
4662 LogInfo(
"Loaded best chain: hashBestChain=%s height=%d date=%s progress=%f",
4695 int nCheckLevel,
int nCheckDepth)
4704 if (nCheckDepth <= 0 || nCheckDepth > chainstate.
m_chain.
Height()) {
4707 nCheckLevel = std::max(0, std::min(4, nCheckLevel));
4708 LogInfo(
"Verifying last %i blocks at level %i", nCheckDepth, nCheckLevel);
4712 int nGoodTransactions = 0;
4715 bool skipped_no_block_data{
false};
4716 bool skipped_l3_checks{
false};
4717 LogInfo(
"Verification progress: 0%%");
4722 const int percentageDone = std::max(1, std::min(99, (
int)(((
double)(chainstate.
m_chain.
Height() - pindex->
nHeight)) / (
double)nCheckDepth * (nCheckLevel >= 4 ? 50 : 100))));
4723 if (reportDone < percentageDone / 10) {
4725 LogInfo(
"Verification progress: %d%%", percentageDone);
4726 reportDone = percentageDone / 10;
4735 LogInfo(
"Block verification stopping at height %d (no data). This could be due to pruning or use of an assumeutxo snapshot.", pindex->
nHeight);
4736 skipped_no_block_data =
true;
4746 if (nCheckLevel >= 1 && !
CheckBlock(block, state, consensus_params)) {
4747 LogPrintf(
"Verification error: found bad block at %d, hash=%s (%s)\n",
4752 if (nCheckLevel >= 2 && pindex) {
4764 if (nCheckLevel >= 3) {
4773 nGoodTransactions = 0;
4774 pindexFailure = pindex;
4776 nGoodTransactions += block.
vtx.size();
4779 skipped_l3_checks =
true;
4784 if (pindexFailure) {
4785 LogPrintf(
"Verification error: coin database inconsistencies found (last %i blocks, %i good transactions before that)\n", chainstate.
m_chain.
Height() - pindexFailure->
nHeight + 1, nGoodTransactions);
4788 if (skipped_l3_checks) {
4789 LogPrintf(
"Skipped verification of level >=3 (insufficient database cache size). Consider increasing -dbcache.\n");
4796 if (nCheckLevel >= 4 && !skipped_l3_checks) {
4798 const int percentageDone = std::max(1, std::min(99, 100 - (
int)(((
double)(chainstate.
m_chain.
Height() - pindex->
nHeight)) / (
double)nCheckDepth * 50)));
4799 if (reportDone < percentageDone / 10) {
4801 LogInfo(
"Verification progress: %d%%", percentageDone);
4802 reportDone = percentageDone / 10;
4811 if (!chainstate.
ConnectBlock(block, state, pindex, coins)) {
4819 LogInfo(
"Verification: No coin database inconsistencies in last %i blocks (%i transactions)", block_count, nGoodTransactions);
4821 if (skipped_l3_checks) {
4824 if (skipped_no_block_data) {
4842 if (!tx->IsCoinBase()) {
4843 for (
const CTxIn &txin : tx->vin) {
4861 if (hashHeads.empty())
return true;
4862 if (hashHeads.size() != 2) {
4863 LogError(
"ReplayBlocks(): unknown inconsistent state\n");
4874 if (
m_blockman.m_block_index.count(hashHeads[0]) == 0) {
4875 LogError(
"ReplayBlocks(): reorganization to unknown block requested\n");
4878 pindexNew = &(
m_blockman.m_block_index[hashHeads[0]]);
4880 if (!hashHeads[1].IsNull()) {
4881 if (
m_blockman.m_block_index.count(hashHeads[1]) == 0) {
4882 LogError(
"ReplayBlocks(): reorganization from unknown block requested\n");
4885 pindexOld = &(
m_blockman.m_block_index[hashHeads[1]]);
4887 assert(pindexFork !=
nullptr);
4891 while (pindexOld != pindexFork) {
4909 pindexOld = pindexOld->
pprev;
4913 int nForkHeight = pindexFork ? pindexFork->
nHeight : 0;
4940 block = block->pprev;
4946void Chainstate::ClearBlockIndexCandidates()
4958 if (!
ret)
return false;
4960 m_blockman.ScanAndUnlinkAlreadyPrunedFiles();
4962 std::vector<CBlockIndex*> vSortedByHeight{
m_blockman.GetAllBlockIndices()};
4963 std::sort(vSortedByHeight.begin(), vSortedByHeight.end(),
4973 if (pindex == GetSnapshotBaseBlock() ||
4978 chainstate->TryAddBlockIndexCandidate(pindex);
4982 m_best_invalid = pindex;
4985 m_best_header = pindex;
5001 if (
m_blockman.m_block_index.count(params.GenesisBlock().GetHash()))
5005 const CBlock& block = params.GenesisBlock();
5007 if (blockPos.IsNull()) {
5008 LogError(
"%s: writing genesis block to disk failed\n", __func__);
5013 }
catch (
const std::runtime_error& e) {
5014 LogError(
"%s: failed to write genesis block: %s\n", __func__, e.what());
5024 std::multimap<uint256, FlatFilePos>* blocks_with_unknown_parent)
5027 assert(!dbp == !blocks_with_unknown_parent);
5029 const auto start{SteadyClock::now()};
5037 uint64_t nRewind = blkdat.GetPos();
5038 while (!blkdat.eof()) {
5041 blkdat.SetPos(nRewind);
5044 unsigned int nSize = 0;
5048 blkdat.FindByte(std::byte(params.MessageStart()[0]));
5049 nRewind = blkdat.GetPos() + 1;
5051 if (buf != params.MessageStart()) {
5058 }
catch (
const std::exception&) {
5065 const uint64_t nBlockPos{blkdat.GetPos()};
5067 dbp->
nPos = nBlockPos;
5068 blkdat.SetLimit(nBlockPos + nSize);
5074 nRewind = nBlockPos + nSize;
5075 blkdat.SkipTo(nRewind);
5077 std::shared_ptr<CBlock> pblock{};
5085 if (dbp && blocks_with_unknown_parent) {
5086 blocks_with_unknown_parent->emplace(header.
hashPrevBlock, *dbp);
5095 blkdat.SetPos(nBlockPos);
5096 pblock = std::make_shared<CBlock>();
5098 nRewind = blkdat.GetPos();
5101 if (
AcceptBlock(pblock, state,
nullptr,
true, dbp,
nullptr,
true)) {
5107 }
else if (hash != params.GetConsensus().hashGenesisBlock && pindex->
nHeight % 1000 == 0) {
5134 bool activation_failure =
false;
5135 for (
auto c :
GetAll()) {
5137 if (!c->ActivateBestChain(state, pblock)) {
5139 activation_failure =
true;
5143 if (activation_failure) {
5150 if (!blocks_with_unknown_parent)
continue;
5153 std::deque<uint256> queue;
5154 queue.push_back(hash);
5155 while (!queue.empty()) {
5158 auto range = blocks_with_unknown_parent->equal_range(head);
5159 while (range.first != range.second) {
5160 std::multimap<uint256, FlatFilePos>::iterator it = range.first;
5161 std::shared_ptr<CBlock> pblockrecursive = std::make_shared<CBlock>();
5163 const auto& block_hash{pblockrecursive->GetHash()};
5167 if (
AcceptBlock(pblockrecursive, dummy,
nullptr,
true, &it->second,
nullptr,
true)) {
5169 queue.push_back(block_hash);
5173 blocks_with_unknown_parent->erase(it);
5177 }
catch (
const std::exception& e) {
5189 LogDebug(
BCLog::REINDEX,
"%s: unexpected data at file offset 0x%x - %s. continuing\n", __func__, (nRewind - 1), e.what());
5192 }
catch (
const std::runtime_error& e) {
5195 LogInfo(
"Loaded %i blocks from external file in %dms", nLoaded, Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
5230 best_hdr_chain.
SetTip(*m_best_header);
5232 std::multimap<const CBlockIndex*, const CBlockIndex*> forward;
5233 for (
auto& [
_, block_index] :
m_blockman.m_block_index) {
5235 if (!best_hdr_chain.
Contains(&block_index)) {
5237 assert(block_index.pprev);
5238 forward.emplace(block_index.pprev, &block_index);
5252 const CBlockIndex* pindexFirstNeverProcessed =
nullptr;
5253 const CBlockIndex* pindexFirstNotTreeValid =
nullptr;
5254 const CBlockIndex* pindexFirstNotTransactionsValid =
nullptr;
5255 const CBlockIndex* pindexFirstNotChainValid =
nullptr;
5256 const CBlockIndex* pindexFirstNotScriptsValid =
nullptr;
5262 const CBlockIndex* snap_base{GetSnapshotBaseBlock()};
5263 const CBlockIndex *snap_first_missing{}, *snap_first_notx{}, *snap_first_notv{}, *snap_first_nocv{}, *snap_first_nosv{};
5264 auto snap_update_firsts = [&] {
5265 if (pindex == snap_base) {
5266 std::swap(snap_first_missing, pindexFirstMissing);
5267 std::swap(snap_first_notx, pindexFirstNeverProcessed);
5268 std::swap(snap_first_notv, pindexFirstNotTransactionsValid);
5269 std::swap(snap_first_nocv, pindexFirstNotChainValid);
5270 std::swap(snap_first_nosv, pindexFirstNotScriptsValid);
5274 while (pindex !=
nullptr) {
5276 if (pindexFirstInvalid ==
nullptr && pindex->nStatus &
BLOCK_FAILED_VALID) pindexFirstInvalid = pindex;
5277 if (pindexFirstMissing ==
nullptr && !(pindex->nStatus &
BLOCK_HAVE_DATA)) {
5278 pindexFirstMissing = pindex;
5280 if (pindexFirstNeverProcessed ==
nullptr && pindex->
nTx == 0) pindexFirstNeverProcessed = pindex;
5283 if (pindex->
pprev !=
nullptr) {
5284 if (pindexFirstNotTransactionsValid ==
nullptr &&
5286 pindexFirstNotTransactionsValid = pindex;
5289 if (pindexFirstNotChainValid ==
nullptr &&
5291 pindexFirstNotChainValid = pindex;
5294 if (pindexFirstNotScriptsValid ==
nullptr &&
5296 pindexFirstNotScriptsValid = pindex;
5301 if (pindex->
pprev ==
nullptr) {
5304 for (
const Chainstate* c : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) {
5305 if (c && c->m_chain.Genesis() !=
nullptr) {
5306 assert(pindex == c->m_chain.Genesis());
5316 assert(pindexFirstMissing == pindexFirstNeverProcessed);
5322 if (snap_base && snap_base->GetAncestor(pindex->
nHeight) == pindex) {
5332 assert((pindexFirstNotTransactionsValid ==
nullptr || pindex == snap_base) == pindex->
HaveNumChainTxs());
5336 assert(pindexFirstNotTreeValid ==
nullptr);
5340 if (pindexFirstInvalid ==
nullptr) {
5347 if (!pindex->
pprev) {
5362 for (
const Chainstate* c : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) {
5363 if (!c || c->m_chain.Tip() ==
nullptr)
continue;
5377 if (!
CBlockIndexWorkComparator()(pindex, c->m_chain.Tip()) && (pindexFirstNeverProcessed ==
nullptr || pindex == snap_base)) {
5381 if (pindexFirstInvalid ==
nullptr) {
5400 if (pindexFirstMissing ==
nullptr || pindex == c->m_chain.Tip() || pindex == c->SnapshotBase()) {
5420 bool foundInUnlinked =
false;
5421 while (rangeUnlinked.first != rangeUnlinked.second) {
5422 assert(rangeUnlinked.first->first == pindex->
pprev);
5423 if (rangeUnlinked.first->second == pindex) {
5424 foundInUnlinked =
true;
5427 rangeUnlinked.first++;
5429 if (pindex->
pprev && (pindex->nStatus &
BLOCK_HAVE_DATA) && pindexFirstNeverProcessed !=
nullptr && pindexFirstInvalid ==
nullptr) {
5434 if (pindexFirstMissing ==
nullptr)
assert(!foundInUnlinked);
5435 if (pindex->
pprev && (pindex->nStatus &
BLOCK_HAVE_DATA) && pindexFirstNeverProcessed ==
nullptr && pindexFirstMissing !=
nullptr) {
5446 for (
const Chainstate* c : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) {
5450 if (pindexFirstInvalid ==
nullptr) {
5451 if (is_active || snap_base->GetAncestor(pindex->
nHeight) == pindex) {
5463 snap_update_firsts();
5464 auto range{forward.equal_range(pindex)};
5465 if (range.first != range.second) {
5467 pindex = range.first->second;
5470 }
else if (best_hdr_chain.
Contains(pindex)) {
5473 pindex = best_hdr_chain[
nHeight];
5481 snap_update_firsts();
5483 if (pindex == pindexFirstInvalid) pindexFirstInvalid =
nullptr;
5484 if (pindex == pindexFirstMissing) pindexFirstMissing =
nullptr;
5485 if (pindex == pindexFirstNeverProcessed) pindexFirstNeverProcessed =
nullptr;
5486 if (pindex == pindexFirstNotTreeValid) pindexFirstNotTreeValid =
nullptr;
5487 if (pindex == pindexFirstNotTransactionsValid) pindexFirstNotTransactionsValid =
nullptr;
5488 if (pindex == pindexFirstNotChainValid) pindexFirstNotChainValid =
nullptr;
5489 if (pindex == pindexFirstNotScriptsValid) pindexFirstNotScriptsValid =
nullptr;
5493 auto rangePar{forward.equal_range(pindexPar)};
5494 while (rangePar.first->second != pindex) {
5495 assert(rangePar.first != rangePar.second);
5500 if (rangePar.first != rangePar.second) {
5502 pindex = rangePar.first->second;
5504 }
else if (pindexPar == best_hdr_chain[
nHeight - 1]) {
5506 pindex = best_hdr_chain[
nHeight];
5508 assert((pindex ==
nullptr) == (pindexPar == best_hdr_chain.
Tip()));
5520 assert(nNodes == forward.size() + best_hdr_chain.
Height() + 1);
5527 return strprintf(
"Chainstate [%s] @ height %d (%s)",
5532bool Chainstate::ResizeCoinsCaches(
size_t coinstip_size,
size_t coinsdb_size)
5545 LogInfo(
"[%s] resized coinsdb cache to %.1f MiB",
5546 this->
ToString(), coinsdb_size * (1.0 / 1024 / 1024));
5547 LogInfo(
"[%s] resized coinstip cache to %.1f MiB",
5548 this->
ToString(), coinstip_size * (1.0 / 1024 / 1024));
5553 if (coinstip_size > old_coinstip_size) {
5567 if (pindex ==
nullptr) {
5576 const int64_t nNow{TicksSinceEpoch<std::chrono::seconds>(
NodeClock::now())};
5577 const auto block_time{
5578 (
Assume(m_best_header) && std::abs(nNow - pindex->
GetBlockTime()) <= Ticks<std::chrono::seconds>(2h) &&
5592 fTxTotal =
data.tx_count + (nNow -
data.nTime) *
data.dTxRate;
5603 if (m_active_chainstate && m_active_chainstate->m_from_snapshot_blockhash) {
5605 return m_active_chainstate->m_from_snapshot_blockhash;
5607 return std::nullopt;
5613 std::vector<Chainstate*>
out;
5615 for (
Chainstate*
cs : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) {
5625 assert(!m_ibd_chainstate);
5626 assert(!m_active_chainstate);
5628 m_ibd_chainstate = std::make_unique<Chainstate>(mempool,
m_blockman, *
this);
5629 m_active_chainstate = m_ibd_chainstate.get();
5630 return *m_active_chainstate;
5642 bool existed = fs::remove(base_blockhash_path);
5644 LogPrintf(
"[snapshot] snapshot chainstate dir being removed lacks %s file\n",
5647 }
catch (
const fs::filesystem_error& e) {
5648 LogWarning(
"[snapshot] failed to remove file %s: %s\n",
5654 LogInfo(
"Removing leveldb dir at %s\n", path_str);
5658 const bool destroyed =
DestroyDB(path_str);
5661 LogPrintf(
"error: leveldb DestroyDB call failed on %s\n", path_str);
5689 if (!
GetParams().AssumeutxoForBlockhash(base_blockhash).has_value()) {
5691 std::string heights_formatted =
util::Join(available_heights,
", ", [&](
const auto& i) {
return util::ToString(i); });
5692 return util::Error{
Untranslated(
strprintf(
"assumeutxo block hash in snapshot metadata not recognized (hash: %s). The following snapshot heights are available: %s",
5694 heights_formatted))};
5698 if (!snapshot_start_block) {
5699 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",
5704 if (start_block_invalid) {
5708 if (!m_best_header || m_best_header->GetAncestor(snapshot_start_block->nHeight) != snapshot_start_block) {
5709 return util::Error{
Untranslated(
"A forked headers-chain with more work than the chain with the snapshot base block header exists. Please proceed to sync without AssumeUtxo.")};
5712 auto mempool{m_active_chainstate->GetMempool()};
5713 if (mempool && mempool->
size() > 0) {
5718 int64_t current_coinsdb_cache_size{0};
5719 int64_t current_coinstip_cache_size{0};
5727 static constexpr double IBD_CACHE_PERC = 0.01;
5728 static constexpr double SNAPSHOT_CACHE_PERC = 0.99;
5740 current_coinsdb_cache_size = this->
ActiveChainstate().m_coinsdb_cache_size_bytes;
5741 current_coinstip_cache_size = this->
ActiveChainstate().m_coinstip_cache_size_bytes;
5746 static_cast<size_t>(current_coinstip_cache_size * IBD_CACHE_PERC),
5747 static_cast<size_t>(current_coinsdb_cache_size * IBD_CACHE_PERC));
5751 return std::make_unique<Chainstate>(
5752 nullptr,
m_blockman, *
this, base_blockhash));
5756 snapshot_chainstate->InitCoinsDB(
5757 static_cast<size_t>(current_coinsdb_cache_size * SNAPSHOT_CACHE_PERC),
5758 in_memory,
false,
"chainstate");
5759 snapshot_chainstate->InitCoinsCache(
5760 static_cast<size_t>(current_coinstip_cache_size * SNAPSHOT_CACHE_PERC));
5764 this->MaybeRebalanceCaches();
5772 snapshot_chainstate.reset();
5776 "Manually remove it before restarting.\n"),
fs::PathToString(*snapshot_datadir)));
5793 return cleanup_bad_snapshot(
Untranslated(
"work does not exceed active chainstate"));
5799 return cleanup_bad_snapshot(
Untranslated(
"could not write base blockhash"));
5803 assert(!m_snapshot_chainstate);
5804 m_snapshot_chainstate.swap(snapshot_chainstate);
5805 const bool chaintip_loaded = m_snapshot_chainstate->LoadChainTip();
5810 Assert(m_active_chainstate->m_mempool->size() == 0);
5811 Assert(!m_snapshot_chainstate->m_mempool);
5812 m_snapshot_chainstate->m_mempool = m_active_chainstate->m_mempool;
5813 m_active_chainstate->m_mempool =
nullptr;
5814 m_active_chainstate = m_snapshot_chainstate.get();
5817 LogInfo(
"[snapshot] successfully activated snapshot %s", base_blockhash.
ToString());
5818 LogInfo(
"[snapshot] (%.2f MB)",
5819 m_snapshot_chainstate->CoinsTip().DynamicMemoryUsage() / (1000 * 1000));
5821 this->MaybeRebalanceCaches();
5822 return snapshot_start_block;
5829 snapshot_loaded ?
"saving snapshot chainstate" :
"flushing coins cache",
5833 coins_cache.
Flush();
5838 const char*
what() const noexcept
override
5840 return "ComputeUTXOStats interrupted.";
5862 if (!snapshot_start_block) {
5869 int base_height = snapshot_start_block->
nHeight;
5872 if (!maybe_au_data) {
5874 "(%d) - refusing to load snapshot", base_height))};
5889 LogInfo(
"[snapshot] loading %d coins from snapshot %s", coins_left, base_blockhash.
ToString());
5890 int64_t coins_processed{0};
5892 while (coins_left > 0) {
5896 size_t coins_per_txid{0};
5899 if (coins_per_txid > coins_left) {
5903 for (
size_t i = 0; i < coins_per_txid; i++) {
5907 outpoint.
hash = txid;
5909 if (coin.
nHeight > base_height ||
5910 outpoint.
n >= std::numeric_limits<
decltype(outpoint.
n)>::max()
5913 coins_count - coins_left))};
5917 coins_count - coins_left))};
5924 if (coins_processed % 1000000 == 0) {
5925 LogInfo(
"[snapshot] %d coins loaded (%.2f%%, %.2f MB)",
5927 static_cast<float>(coins_processed) * 100 /
static_cast<float>(coins_count),
5935 if (coins_processed % 120000 == 0) {
5941 return snapshot_chainstate.GetCoinsCacheSizeState());
5954 }
catch (
const std::ios_base::failure&) {
5967 bool out_of_coins{
false};
5969 std::byte left_over_byte;
5970 coins_file >> left_over_byte;
5971 }
catch (
const std::ios_base::failure&) {
5973 out_of_coins =
true;
5975 if (!out_of_coins) {
5980 LogInfo(
"[snapshot] loaded %d (%.2f MB) coins from snapshot %s",
5994 std::optional<CCoinsStats> maybe_stats;
6002 if (!maybe_stats.has_value()) {
6023 constexpr int AFTER_GENESIS_START{1};
6025 for (
int i = AFTER_GENESIS_START; i <= snapshot_chainstate.
m_chain.
Height(); ++i) {
6026 index = snapshot_chainstate.
m_chain[i];
6043 assert(index == snapshot_start_block);
6047 LogInfo(
"[snapshot] validated snapshot (%.2f MB)",
6069 if (m_ibd_chainstate.get() == &this->ActiveChainstate() ||
6070 !this->IsUsable(m_snapshot_chainstate.get()) ||
6071 !this->IsUsable(m_ibd_chainstate.get()) ||
6072 !m_ibd_chainstate->m_chain.Tip()) {
6078 const int snapshot_base_height = *
Assert(this->GetSnapshotBaseHeight());
6081 if (index_new.
nHeight < snapshot_base_height) {
6091 "%s failed to validate the -assumeutxo snapshot state. "
6092 "This indicates a hardware problem, or a bug in the software, or a "
6093 "bad software modification that allowed an invalid snapshot to be "
6094 "loaded. As a result of this, the node will shut down and stop using any "
6095 "state that was built on the snapshot, resetting the chain height "
6096 "from %d to %d. On the next "
6097 "restart, the node will resume syncing from %d "
6098 "without using any snapshot data. "
6099 "Please report this incident to %s, including how you obtained the snapshot. "
6100 "The invalid snapshot chainstate will be left on disk in case it is "
6101 "helpful in diagnosing the issue that caused this error."),
6102 CLIENT_NAME, snapshot_tip_height, snapshot_base_height, snapshot_base_height, CLIENT_BUGREPORT
6106 LogError(
"[snapshot] deleting snapshot, reverting to validated chain, and stopping node\n");
6108 m_active_chainstate = m_ibd_chainstate.get();
6109 m_snapshot_chainstate->m_disabled =
true;
6113 auto rename_result = m_snapshot_chainstate->InvalidateCoinsDBOnDisk();
6114 if (!rename_result) {
6122 LogPrintf(
"[snapshot] supposed base block %s does not match the "
6123 "snapshot base block %s (height %d). Snapshot is not valid.\n",
6124 index_new.
ToString(), snapshot_blockhash.
ToString(), snapshot_base_height);
6125 handle_invalid_snapshot();
6131 int curr_height = m_ibd_chainstate->m_chain.Height();
6133 assert(snapshot_base_height == curr_height);
6138 CCoinsViewDB& ibd_coins_db = m_ibd_chainstate->CoinsDB();
6139 m_ibd_chainstate->ForceFlushStateToDisk();
6142 if (!maybe_au_data) {
6143 LogPrintf(
"[snapshot] assumeutxo data not found for height "
6144 "(%d) - refusing to validate snapshot\n", curr_height);
6145 handle_invalid_snapshot();
6150 std::optional<CCoinsStats> maybe_ibd_stats;
6151 LogInfo(
"[snapshot] computing UTXO stats for background chainstate to validate "
6152 "snapshot - this could take a few minutes");
6155 CoinStatsHashType::HASH_SERIALIZED,
6164 if (!maybe_ibd_stats) {
6165 LogPrintf(
"[snapshot] failed to generate stats for validation coins db\n");
6169 handle_invalid_snapshot();
6172 const auto& ibd_stats = *maybe_ibd_stats;
6181 LogPrintf(
"[snapshot] hash mismatch: actual=%s, expected=%s\n",
6182 ibd_stats.hashSerialized.ToString(),
6184 handle_invalid_snapshot();
6188 LogInfo(
"[snapshot] snapshot beginning at %s has been fully validated",
6191 m_ibd_chainstate->m_disabled =
true;
6192 this->MaybeRebalanceCaches();
6200 assert(m_active_chainstate);
6201 return *m_active_chainstate;
6207 return m_snapshot_chainstate && m_active_chainstate == m_snapshot_chainstate.get();
6210void ChainstateManager::MaybeRebalanceCaches()
6213 bool ibd_usable = this->
IsUsable(m_ibd_chainstate.get());
6214 bool snapshot_usable = this->
IsUsable(m_snapshot_chainstate.get());
6215 assert(ibd_usable || snapshot_usable);
6217 if (ibd_usable && !snapshot_usable) {
6222 else if (snapshot_usable && !ibd_usable) {
6224 LogInfo(
"[snapshot] allocating all cache to the snapshot chainstate");
6228 else if (ibd_usable && snapshot_usable) {
6233 m_ibd_chainstate->ResizeCoinsCaches(
6235 m_snapshot_chainstate->ResizeCoinsCaches(
6238 m_snapshot_chainstate->ResizeCoinsCaches(
6240 m_ibd_chainstate->ResizeCoinsCaches(
6246void ChainstateManager::ResetChainstates()
6248 m_ibd_chainstate.reset();
6249 m_snapshot_chainstate.reset();
6250 m_active_chainstate =
nullptr;
6260 if (!opts.check_block_index.has_value()) opts.
check_block_index = opts.chainparams.DefaultConsistencyChecks();
6261 if (!opts.minimum_chain_work.has_value()) opts.minimum_chain_work =
UintToArith256(opts.chainparams.GetConsensus().nMinimumChainWork);
6262 if (!opts.assumed_valid_block.has_value()) opts.assumed_valid_block = opts.chainparams.GetConsensus().defaultAssumeValid;
6263 return std::move(opts);
6268 m_interrupt{interrupt},
6270 m_blockman{interrupt,
std::move(blockman_options)},
6271 m_validation_cache{m_options.script_execution_cache_bytes, m_options.signature_cache_bytes}
6282bool ChainstateManager::DetectSnapshotChainstate()
6284 assert(!m_snapshot_chainstate);
6290 if (!base_blockhash) {
6293 LogInfo(
"[snapshot] detected active snapshot chainstate (%s) - loading",
6294 fs::PathToString(*path));
6296 this->ActivateExistingSnapshot(*base_blockhash);
6302 assert(!m_snapshot_chainstate);
6303 m_snapshot_chainstate =
6304 std::make_unique<Chainstate>(
nullptr,
m_blockman, *
this, base_blockhash);
6305 LogInfo(
"[snapshot] switching active chainstate to %s", m_snapshot_chainstate->ToString());
6308 Assert(m_active_chainstate->m_mempool->size() == 0);
6309 Assert(!m_snapshot_chainstate->m_mempool);
6310 m_snapshot_chainstate->m_mempool = m_active_chainstate->m_mempool;
6311 m_active_chainstate->m_mempool =
nullptr;
6312 m_active_chainstate = m_snapshot_chainstate.get();
6313 return *m_snapshot_chainstate;
6318 return (block_index.
nHeight==91842 && block_index.
GetBlockHash() ==
uint256{
"00000000000a4d0a398161ffc163c503763b1f4360639393e0e4c8e300e0caec"}) ||
6319 (block_index.
nHeight==91880 && block_index.
GetBlockHash() ==
uint256{
"00000000000743f190a18c5577a3c2d2a1f610ae9601ac046a38084ccb7cd721"});
6324 return (block_height==91722 && block_hash ==
uint256{
"00000000000271a2dc26e7667f8419f2e15416dc6955e5a6c6cdf3f2574dd08e"}) ||
6325 (block_height==91812 && block_hash ==
uint256{
"00000000000af0aed4792b1acee3d966af36cf5def14935db8de83d6f9306f2f"});
6332 assert(
cs.m_from_snapshot_blockhash);
6333 auto storage_path_maybe =
cs.CoinsDB().StoragePath();
6335 assert(storage_path_maybe);
6336 return *storage_path_maybe;
6346 auto invalid_path = snapshot_datadir +
"_INVALID";
6349 LogInfo(
"[snapshot] renaming snapshot datadir %s to %s", dbpath, target);
6355 fs::rename(snapshot_datadir, invalid_path);
6356 }
catch (
const fs::filesystem_error& e) {
6360 LogPrintf(
"%s: error renaming file '%s' -> '%s': %s\n",
6361 __func__, src_str, dest_str, e.what());
6363 "Rename of '%s' -> '%s' failed. "
6364 "You should resolve this by manually moving or deleting the invalid "
6365 "snapshot directory %s, otherwise you will encounter the same error again "
6366 "on the next startup."),
6367 src_str, dest_str, src_str)};
6372bool ChainstateManager::DeleteSnapshotChainstate()
6375 Assert(m_snapshot_chainstate);
6376 Assert(m_ibd_chainstate);
6380 LogPrintf(
"Deletion of %s failed. Please remove it manually to continue reindexing.\n",
6381 fs::PathToString(snapshot_datadir));
6384 m_active_chainstate = m_ibd_chainstate.get();
6385 m_active_chainstate->m_mempool = m_snapshot_chainstate->m_mempool;
6386 m_snapshot_chainstate.reset();
6400const CBlockIndex* ChainstateManager::GetSnapshotBaseBlock()
const
6402 return m_active_chainstate ? m_active_chainstate->SnapshotBase() :
nullptr;
6405std::optional<int> ChainstateManager::GetSnapshotBaseHeight()
const
6407 const CBlockIndex* base = this->GetSnapshotBaseBlock();
6408 return base ? std::make_optional(base->
nHeight) :
std::nullopt;
6411void ChainstateManager::RecalculateBestHeader()
6415 for (
auto& entry :
m_blockman.m_block_index) {
6416 if (!(entry.second.nStatus &
BLOCK_FAILED_MASK) && m_best_header->nChainWork < entry.second.nChainWork) {
6417 m_best_header = &entry.second;
6422bool ChainstateManager::ValidatedSnapshotCleanup()
6426 if (!(chainstate && chainstate->HasCoinsViews())) {
6429 return chainstate->CoinsDB().StoragePath();
6431 std::optional<fs::path> ibd_chainstate_path_maybe = get_storage_path(m_ibd_chainstate);
6432 std::optional<fs::path> snapshot_chainstate_path_maybe = get_storage_path(m_snapshot_chainstate);
6441 if (!ibd_chainstate_path_maybe || !snapshot_chainstate_path_maybe) {
6442 LogPrintf(
"[snapshot] snapshot chainstate cleanup cannot happen with "
6443 "in-memory chainstates. You are testing, right?\n");
6447 const auto& snapshot_chainstate_path = *snapshot_chainstate_path_maybe;
6448 const auto& ibd_chainstate_path = *ibd_chainstate_path_maybe;
6456 this->ResetChainstates();
6461 LogInfo(
"[snapshot] deleting background chainstate directory (now unnecessary) (%s)",
6462 fs::PathToString(ibd_chainstate_path));
6464 fs::path tmp_old{ibd_chainstate_path +
"_todelete"};
6466 auto rename_failed_abort = [
this](
6469 const fs::filesystem_error& err) {
6470 LogError(
"[snapshot] Error renaming path (%s) -> (%s): %s\n",
6471 fs::PathToString(p_old), fs::PathToString(p_new), err.what());
6473 "Rename of '%s' -> '%s' failed. "
6474 "Cannot clean up the background chainstate leveldb directory."),
6475 fs::PathToString(p_old), fs::PathToString(p_new)));
6479 fs::rename(ibd_chainstate_path, tmp_old);
6480 }
catch (
const fs::filesystem_error& e) {
6481 rename_failed_abort(ibd_chainstate_path, tmp_old, e);
6485 LogInfo(
"[snapshot] moving snapshot chainstate (%s) to "
6486 "default chainstate directory (%s)",
6487 fs::PathToString(snapshot_chainstate_path), fs::PathToString(ibd_chainstate_path));
6490 fs::rename(snapshot_chainstate_path, ibd_chainstate_path);
6491 }
catch (
const fs::filesystem_error& e) {
6492 rename_failed_abort(snapshot_chainstate_path, ibd_chainstate_path, e);
6499 LogPrintf(
"Deletion of %s failed. Please remove it manually, as the "
6500 "directory is now unnecessary.\n",
6501 fs::PathToString(tmp_old));
6503 LogInfo(
"[snapshot] deleted background chainstate directory (%s)",
6504 fs::PathToString(ibd_chainstate_path));
6509Chainstate& ChainstateManager::GetChainstateForIndexing()
6514 return (this->
GetAll().size() > 1) ? *m_ibd_chainstate : *m_active_chainstate;
6517std::pair<int, int> ChainstateManager::GetPruneRange(
const Chainstate& chainstate,
int last_height_can_prune)
6524 if (this->
GetAll().size() > 1 && m_snapshot_chainstate.get() == &chainstate) {
6527 prune_start = *
Assert(GetSnapshotBaseHeight()) + 1;
6530 int max_prune = std::max<int>(
6539 int prune_end = std::min(last_height_can_prune, max_prune);
6541 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
script_verify_flags m_flags
std::optional< std::pair< ScriptError, std::string > > operator()()
const CTransaction * ptxTo
Serialized script, used inside transaction inputs and outputs.
The basic transaction that is broadcasted on the network and contained in blocks.
const std::vector< CTxOut > vout
const Wtxid & GetWitnessHash() const LIFETIMEBOUND
const Txid & GetHash() const LIFETIMEBOUND
const std::vector< CTxIn > vin
An input of a transaction.
CTxMemPool::txiter TxHandle
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
RecursiveMutex cs
This mutex needs to be locked when accessing mapTx or other members that are guarded by it.
void check(const CCoinsViewCache &active_coins_tip, int64_t spendheight) const EXCLUSIVE_LOCKS_REQUIRED(void removeRecursive(const CTransaction &tx, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs)
If sanity-checking is turned on, check makes sure the pool is consistent (does not contain two transa...
void UpdateTransactionsFromBlock(const std::vector< Txid > &vHashesToUpdate) EXCLUSIVE_LOCKS_REQUIRED(cs
UpdateTransactionsFromBlock is called when adding transactions from a disconnected block back to the ...
void AddTransactionsUpdated(unsigned int n)
CTransactionRef get(const Txid &hash) const
size_t DynamicMemoryUsage() const
void removeForReorg(CChain &chain, std::function< bool(txiter)> filter_final_and_mature) EXCLUSIVE_LOCKS_REQUIRED(cs
After reorg, filter the entries that would no longer be valid in the next block, and update the entri...
bool exists(const Txid &txid) const
std::set< txiter, CompareIteratorByHash > setEntries
void removeForBlock(const std::vector< CTransactionRef > &vtx, unsigned int nBlockHeight) EXCLUSIVE_LOCKS_REQUIRED(cs)
indexed_transaction_set::nth_index< 0 >::type::const_iterator txiter
unsigned long size() const
An output of a transaction.
Undo information for a CTransaction.
std::vector< Coin > vprevout
VerifyDBResult VerifyDB(Chainstate &chainstate, const Consensus::Params &consensus_params, CCoinsView &coinsview, int nCheckLevel, int nCheckDepth) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
kernel::Notifications & m_notifications
CVerifyDB(kernel::Notifications ¬ifications)
Chainstate stores and provides an API to update our local knowledge of the current best chain.
void InitCoinsCache(size_t cache_size_bytes) EXCLUSIVE_LOCKS_REQUIRED(bool CanFlushToDisk() const EXCLUSIVE_LOCKS_REQUIRED(
Initialize the in-memory coins cache (to be done after the health of the on-disk database is verified...
Mutex m_chainstate_mutex
The ChainState Mutex A lock that must be held when modifying this ChainState - held in ActivateBestCh...
CChain m_chain
The current chain of blockheaders we consult and build on.
CTxMemPool * GetMempool()
bool RollforwardBlock(const CBlockIndex *pindex, CCoinsViewCache &inputs) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Apply the effects of a block on the utxo cache, ignoring that it may already have been applied.
size_t m_coinstip_cache_size_bytes
The cache size of the in-memory coins view.
void UpdateTip(const CBlockIndex *pindexNew) EXCLUSIVE_LOCKS_REQUIRED(NodeClock::time_poin m_next_write)
Check warning conditions and do some notifications on new chain tip set.
CCoinsViewCache & CoinsTip() EXCLUSIVE_LOCKS_REQUIRED(
bool LoadChainTip() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Update the chain tip based on database information, i.e.
size_t m_coinsdb_cache_size_bytes
The cache size of the on-disk coins view.
bool PreciousBlock(BlockValidationState &state, CBlockIndex *pindex) LOCKS_EXCLUDED(bool InvalidateBlock(BlockValidationState &state, CBlockIndex *pindex) LOCKS_EXCLUDED(void SetBlockFailureFlags(CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(voi ResetBlockFailureFlags)(CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Mark a block as precious and reorganize.
void InvalidBlockFound(CBlockIndex *pindex, const BlockValidationState &state) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
void CheckForkWarningConditions() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
void ForceFlushStateToDisk()
Unconditionally flush all changes to disk.
bool ConnectTip(BlockValidationState &state, CBlockIndex *pindexNew, std::shared_ptr< const CBlock > block_to_connect, ConnectTrace &connectTrace, DisconnectedBlockTransactions &disconnectpool) EXCLUSIVE_LOCKS_REQUIRED(cs_main
Connect a new block to m_chain.
bool LoadGenesisBlock()
Ensures we have a genesis block in the block tree, possibly writing one to disk.
const std::optional< uint256 > m_from_snapshot_blockhash
The blockhash which is the base of the snapshot this chainstate was created from.
bool ActivateBestChain(BlockValidationState &state, std::shared_ptr< const CBlock > pblock=nullptr) LOCKS_EXCLUDED(DisconnectResult DisconnectBlock(const CBlock &block, const CBlockIndex *pindex, CCoinsViewCache &view) EXCLUSIVE_LOCKS_REQUIRED(boo ConnectBlock)(const CBlock &block, BlockValidationState &state, CBlockIndex *pindex, CCoinsViewCache &view, bool fJustCheck=false) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Find the best known block, and make it the tip of the block chain.
CTxMemPool * m_mempool
Optional mempool that is kept in sync with the chain.
CCoinsViewDB & CoinsDB() EXCLUSIVE_LOCKS_REQUIRED(
std::atomic_bool m_prev_script_checks_logged
bool DisconnectTip(BlockValidationState &state, DisconnectedBlockTransactions *disconnectpool) EXCLUSIVE_LOCKS_REQUIRED(cs_main
Disconnect m_chain's tip.
CBlockIndex * FindMostWorkChain() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Return the tip of the chain with the most work in it, that isn't known to be invalid (it's however fa...
ChainstateRole GetRole() const EXCLUSIVE_LOCKS_REQUIRED(void InitCoinsDB(size_t cache_size_bytes, bool in_memory, bool should_wipe, fs::path leveldb_name="chainstate")
Return the current role of the chainstate.
ChainstateManager & m_chainman
The chainstate manager that owns this chainstate.
std::unique_ptr< CoinsViews > m_coins_views
Manages the UTXO set, which is a reflection of the contents of m_chain.
bool ReplayBlocks()
Replay blocks that aren't fully applied to the database.
void PruneBlockIndexCandidates()
Delete all entries in setBlockIndexCandidates that are worse than the current tip.
const CBlockIndex *SnapshotBase() const EXCLUSIVE_LOCKS_REQUIRED(std::set< CBlockIndex *, node::CBlockIndexWorkComparator > setBlockIndexCandidates
The base of the snapshot this chainstate was created from.
void TryAddBlockIndexCandidate(CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
void PruneAndFlush()
Prune blockfiles from the disk if necessary and then flush chainstate changes if we pruned.
bool ResizeCoinsCaches(size_t coinstip_size, size_t coinsdb_size) EXCLUSIVE_LOCKS_REQUIRED(bool FlushStateToDisk(BlockValidationState &state, FlushStateMode mode, int nManualPruneHeight=0)
Resize the CoinsViews caches dynamically and flush state to disk.
node::BlockManager & m_blockman
Reference to a BlockManager instance which itself is shared across all Chainstate instances.
void MaybeUpdateMempoolForReorg(DisconnectedBlockTransactions &disconnectpool, bool fAddToMempool) EXCLUSIVE_LOCKS_REQUIRED(cs_main
Make mempool consistent after a reorg, by re-adding or recursively erasing disconnected block transac...
bool ActivateBestChainStep(BlockValidationState &state, CBlockIndex *pindexMostWork, const std::shared_ptr< const CBlock > &pblock, bool &fInvalidFound, ConnectTrace &connectTrace) EXCLUSIVE_LOCKS_REQUIRED(cs_main
Try to make some progress towards making pindexMostWork the active block.
void ClearBlockIndexCandidates() EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex * FindForkInGlobalIndex(const CBlockLocator &locator) const EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Find the last common block of this chain and a locator.
void InvalidChainFound(CBlockIndex *pindexNew) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Chainstate(CTxMemPool *mempool, node::BlockManager &blockman, ChainstateManager &chainman, std::optional< uint256 > from_snapshot_blockhash=std::nullopt)
bool NeedsRedownload() const EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Whether the chain state needs to be redownloaded due to lack of witness data.
CoinsCacheSizeState GetCoinsCacheSizeState() EXCLUSIVE_LOCKS_REQUIRED(CoinsCacheSizeState GetCoinsCacheSizeState(size_t max_coins_cache_size_bytes, size_t max_mempool_size_bytes) EXCLUSIVE_LOCKS_REQUIRED(std::string ToString() EXCLUSIVE_LOCKS_REQUIRED(RecursiveMutex * MempoolMutex() const LOCK_RETURNED(m_mempool -> cs)
Dictates whether we need to flush the cache to disk or not.
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
util::Result< void > PopulateAndValidateSnapshot(Chainstate &snapshot_chainstate, AutoFile &coins_file, const node::SnapshotMetadata &metadata)
Internal helper for ActivateSnapshot().
const uint256 & AssumedValidBlock() const
SnapshotCompletionResult MaybeCompleteSnapshotValidation() EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex *GetSnapshotBaseBlock() const EXCLUSIVE_LOCKS_REQUIRED(Chainstate ActiveChainstate)() const
Once the background validation chainstate has reached the height which is the base of the UTXO snapsh...
ValidationCache m_validation_cache
double GuessVerificationProgress(const CBlockIndex *pindex) const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Guess verification progress (as a fraction between 0.0=genesis and 1.0=current tip).
size_t m_total_coinstip_cache
The total number of bytes available for us to use across all in-memory coins caches.
std::vector< unsigned char > GenerateCoinbaseCommitment(CBlock &block, const CBlockIndex *pindexPrev) const
Produce the necessary coinbase commitment for a block (modifies the hash, don't call for mined blocks...
MempoolAcceptResult ProcessTransaction(const CTransactionRef &tx, bool test_accept=false) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Try to add a transaction to the memory pool.
kernel::Notifications & GetNotifications() const
bool IsInitialBlockDownload() const
Check whether we are doing an initial block download (synchronizing from disk or network)
void ReceivedBlockTransactions(const CBlock &block, CBlockIndex *pindexNew, const FlatFilePos &pos) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Mark a block as having its data received and checked (up to BLOCK_VALID_TRANSACTIONS).
bool ShouldCheckBlockIndex() const
RecursiveMutex & GetMutex() const LOCK_RETURNED(
Alias for cs_main.
bool IsSnapshotValidated() const EXCLUSIVE_LOCKS_REQUIRED(
Is there a snapshot in use and has it been fully validated?
CBlockIndex * ActiveTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
bool ProcessNewBlock(const std::shared_ptr< const CBlock > &block, bool force_processing, bool min_pow_checked, bool *new_block) LOCKS_EXCLUDED(cs_main)
Process an incoming block.
bool BackgroundSyncInProgress() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
The state of a background sync (for net processing)
size_t m_total_coinsdb_cache
The total number of bytes available for us to use across all leveldb coins databases.
std::atomic< bool > m_cached_finished_ibd
Whether initial block download has ended and IsInitialBlockDownload should return false from now on.
void CheckBlockIndex() const
Make various assertions about the state of the block index.
const util::SignalInterrupt & m_interrupt
void LoadExternalBlockFile(AutoFile &file_in, FlatFilePos *dbp=nullptr, std::multimap< uint256, FlatFilePos > *blocks_with_unknown_parent=nullptr)
Import blocks from an external file.
int ActiveHeight() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
VersionBitsCache m_versionbitscache
Track versionbit status.
bool IsSnapshotActive() const
std::function< void()> snapshot_download_completed
Function to restart active indexes; set dynamically to avoid a circular dependency on base/index....
const CChainParams & GetParams() const
bool ProcessNewBlockHeaders(std::span< const CBlockHeader > headers, bool min_pow_checked, BlockValidationState &state, const CBlockIndex **ppindex=nullptr) LOCKS_EXCLUDED(cs_main)
Process incoming block headers.
const Consensus::Params & GetConsensus() const
ChainstateManager(const util::SignalInterrupt &interrupt, Options options, node::BlockManager::Options blockman_options)
const arith_uint256 & MinimumChainWork() const
util::Result< CBlockIndex * > ActivateSnapshot(AutoFile &coins_file, const node::SnapshotMetadata &metadata, bool in_memory)
Construct and activate a Chainstate on the basis of UTXO snapshot data.
bool LoadBlockIndex() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Load the block tree and coins database from disk, initializing state if we're running with -reindex.
std::optional< uint256 > SnapshotBlockhash() const
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
bool AcceptBlockHeader(const CBlockHeader &block, BlockValidationState &state, CBlockIndex **ppindex, bool min_pow_checked) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
If a block header hasn't already been seen, call CheckBlockHeader on it, ensure that it doesn't desce...
void ReportHeadersPresync(const arith_uint256 &work, int64_t height, int64_t timestamp)
This is used by net_processing to report pre-synchronization progress of headers, as headers are not ...
arith_uint256 nLastPreciousChainwork
chainwork for the last block that preciousblock has been applied to.
bool NotifyHeaderTip() LOCKS_EXCLUDED(GetMutex())
Chainstate &InitializeChainstate(CTxMemPool *mempool) EXCLUSIVE_LOCKS_REQUIRED(std::vector< Chainstate * GetAll)()
Instantiate a new chainstate.
void MaybeRebalanceCaches() EXCLUSIVE_LOCKS_REQUIRED(void UpdateUncommittedBlockStructures(CBlock &block, const CBlockIndex *pindexPrev) const
Check to see if caches are out of balance and if so, call ResizeCoinsCaches() as needed.
bool DetectSnapshotChainstate() EXCLUSIVE_LOCKS_REQUIRED(void ResetChainstates() EXCLUSIVE_LOCKS_REQUIRED(bool DeleteSnapshotChainstate() EXCLUSIVE_LOCKS_REQUIRED(Chainstate &ActivateExistingSnapshot(uint256 base_blockhash) EXCLUSIVE_LOCKS_REQUIRED(bool ValidatedSnapshotCleanup() EXCLUSIVE_LOCKS_REQUIRED(Chainstate &GetChainstateForIndexing() EXCLUSIVE_LOCKS_REQUIRED(std::pair< int, int > GetPruneRange(const Chainstate &chainstate, int last_height_can_prune) EXCLUSIVE_LOCKS_REQUIRED(std::optional< int > GetSnapshotBaseHeight() const EXCLUSIVE_LOCKS_REQUIRED(void RecalculateBestHeader() EXCLUSIVE_LOCKS_REQUIRED(CCheckQueue< CScriptCheck > & GetCheckQueue()
When starting up, search the datadir for a chainstate based on a UTXO snapshot that is in the process...
bool IsUsable(const Chainstate *const cs) const EXCLUSIVE_LOCKS_REQUIRED(
Return true if a chainstate is considered usable.
int32_t nBlockReverseSequenceId
Decreasing counter (used by subsequent preciousblock calls).
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
bool AcceptBlock(const std::shared_ptr< const CBlock > &pblock, BlockValidationState &state, CBlockIndex **ppindex, bool fRequested, const FlatFilePos *dbp, bool *fNewBlock, bool min_pow_checked) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Sufficiently validate a block for disk storage (and store on disk).
CTxOut out
unspent transaction output
bool IsSpent() const
Either this coin never existed (see e.g.
uint32_t nHeight
at which height this containing transaction was included in the active block chain
unsigned int fCoinBase
whether containing transaction was a coinbase
CoinsViews(DBParams db_params, CoinsViewOptions options)
This constructor initializes CCoinsViewDB and CCoinsViewErrorCatcher instances, but it does not creat...
Used to track blocks whose transactions were applied to the UTXO state as a part of a single Activate...
std::vector< PerBlockConnectTrace > & GetBlocksConnected()
std::vector< PerBlockConnectTrace > blocksConnected
void BlockConnected(CBlockIndex *pindex, std::shared_ptr< const CBlock > pblock)
std::pair< uint32_t, size_t > setup_bytes(size_t bytes)
setup_bytes is a convenience function which accounts for internal memory usage when deciding how many...
void insert(Element e)
insert loops at most depth_limit times trying to insert a hash at various locations in the table via ...
bool contains(const Element &e, const bool erase) const
contains iterates through the hash locations for a given element and checks to see if it is present.
DisconnectedBlockTransactions.
std::list< CTransactionRef > take()
Clear all data structures and return the list of transactions.
void removeForBlock(const std::vector< CTransactionRef > &vtx)
Remove any entries that are in this block.
std::vector< CTransactionRef > AddTransactionsFromBlock(const std::vector< CTransactionRef > &vtx)
Add transactions from the block, iterating through vtx in reverse order.
Tp rand_uniform_delay(const Tp &time, typename Tp::duration range) noexcept
Return the time point advanced by a uniform random duration.
Convenience class for initializing and passing the script execution cache and signature cache.
ValidationCache(size_t script_execution_cache_bytes, size_t signature_cache_bytes)
CuckooCache::cache< uint256, SignatureCacheHasher > m_script_execution_cache
CSHA256 ScriptExecutionCacheHasher() const
Return a copy of the pre-initialized hasher.
CSHA256 m_script_execution_cache_hasher
Pre-initialized hasher to avoid having to recreate it for every hash calculation.
SignatureCache m_signature_cache
void BlockDisconnected(const std::shared_ptr< const CBlock > &, const CBlockIndex *pindex)
void BlockChecked(const std::shared_ptr< const CBlock > &, const BlockValidationState &)
void NewPoWValidBlock(const CBlockIndex *, const std::shared_ptr< const CBlock > &)
void UpdatedBlockTip(const CBlockIndex *, const CBlockIndex *, bool fInitialDownload)
void ChainStateFlushed(ChainstateRole, const CBlockLocator &)
void ActiveTipChange(const CBlockIndex &, bool)
void BlockConnected(ChainstateRole, const std::shared_ptr< const CBlock > &, const CBlockIndex *pindex)
std::string GetRejectReason() const
std::string GetDebugMessage() const
bool Error(const std::string &reject_reason)
bool Invalid(Result result, const std::string &reject_reason="", const std::string &debug_message="")
std::string ToString() const
std::vector< std::pair< int, bool > > CheckUnknownActivations(const CBlockIndex *pindex, const CChainParams &chainparams) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Check for unknown activations Returns a vector containing the bit number used for signalling and a bo...
void Clear() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
256-bit unsigned big integer.
constexpr bool IsNull() const
std::string ToString() const
constexpr unsigned char * begin()
A base class defining functions for notifying about certain kernel events.
virtual void headerTip(SynchronizationState state, int64_t height, int64_t timestamp, bool presync)
virtual void fatalError(const bilingual_str &message)
The fatal error notification is sent to notify the user when an error occurs in kernel code that can'...
virtual void warningSet(Warning id, const bilingual_str &message)
virtual void progress(const bilingual_str &title, int progress_percent, bool resume_possible)
virtual InterruptResult blockTip(SynchronizationState state, const CBlockIndex &index, double verification_progress)
virtual void warningUnset(Warning id)
Maintains a tree of blocks (stored in m_block_index) which is consulted to determine where the most-w...
const kernel::BlockManagerOpts m_opts
RecursiveMutex cs_LastBlockFile
bool FlushChainstateBlockFile(int tip_height)
void FindFilesToPrune(std::set< int > &setFilesToPrune, int last_prune, const Chainstate &chain, ChainstateManager &chainman)
Prune block and undo files (blk???.dat and rev???.dat) so that the disk space used is less than a use...
void UpdateBlockInfo(const CBlock &block, unsigned int nHeight, const FlatFilePos &pos)
Update blockfile info while processing a block during reindex.
CBlockIndex * LookupBlockIndex(const uint256 &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
bool ReadBlockUndo(CBlockUndo &blockundo, const CBlockIndex &index) const
std::atomic_bool m_blockfiles_indexed
Whether all blockfiles have been added to the block tree database.
std::vector< CBlockIndex * > GetAllBlockIndices() EXCLUSIVE_LOCKS_REQUIRED(std::multimap< CBlockIndex *, CBlockIndex * > m_blocks_unlinked
All pairs A->B, where A (or one of its ancestors) misses transactions, but B has transactions.
std::set< CBlockIndex * > m_dirty_blockindex
Dirty block index entries.
bool LoadingBlocks() const
void UnlinkPrunedFiles(const std::set< int > &setFilesToPrune) const
Actually unlink the specified files.
bool WriteBlockIndexDB() EXCLUSIVE_LOCKS_REQUIRED(bool LoadBlockIndexDB(const std::optional< uint256 > &snapshot_blockhash) EXCLUSIVE_LOCKS_REQUIRED(void ScanAndUnlinkAlreadyPrunedFiles() EXCLUSIVE_LOCKS_REQUIRED(CBlockIndex * AddToBlockIndex(const CBlockHeader &block, CBlockIndex *&best_header) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Remove any pruned block & undo files that are still on disk.
bool CheckBlockDataAvailability(const CBlockIndex &upper_block LIFETIMEBOUND, const CBlockIndex &lower_block LIFETIMEBOUND) EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex *GetFirstBlock(const CBlockIndex &upper_block LIFETIMEBOUND, uint32_t status_mask, const CBlockIndex *lower_block=nullptr) const EXCLUSIVE_LOCKS_REQUIRED(boo m_have_pruned)
Check if all blocks in the [upper_block, lower_block] range have data available.
bool ReadBlock(CBlock &block, const FlatFilePos &pos, const std::optional< uint256 > &expected_hash) const
Functions for disk access for blocks.
bool m_check_for_pruning
Global flag to indicate we should check to see if there are block/undo files that should be deleted.
bool IsPruneMode() const
Whether running in -prune mode.
void FindFilesToPruneManual(std::set< int > &setFilesToPrune, int nManualPruneHeight, const Chainstate &chain, ChainstateManager &chainman)
bool WriteBlockUndo(const CBlockUndo &blockundo, BlockValidationState &state, CBlockIndex &block) EXCLUSIVE_LOCKS_REQUIRED(FlatFilePos WriteBlock(const CBlock &block, int nHeight)
Store block on disk and update block file statistics.
std::optional< int > m_snapshot_height
The height of the base block of an assumeutxo snapshot, if one is in use.
std::string ToString() const
constexpr const std::byte * begin() const
const uint256 & ToUint256() const LIFETIMEBOUND
std::string GetHex() const
Helper class that manages an interrupt flag, and allows a thread or signal to interrupt another threa...
std::string FormatFullVersion()
const Coin & AccessByTxid(const CCoinsViewCache &view, const Txid &txid)
Utility function to find any unspent output with a given txid.
void AddCoins(CCoinsViewCache &cache, const CTransaction &tx, int nHeight, bool check_for_overwrite)
Utility function to add all of a transaction's outputs to a cache.
uint256 BlockMerkleRoot(const CBlock &block, bool *mutated)
uint256 BlockWitnessMerkleRoot(const CBlock &block, bool *mutated)
static constexpr int NO_WITNESS_COMMITMENT
Index marker for when no witness commitment is present in a coinbase transaction.
static constexpr size_t MINIMUM_WITNESS_COMMITMENT
Minimum size of a witness commitment structure.
static int64_t GetBlockWeight(const CBlock &block)
@ BLOCK_HEADER_LOW_WORK
the block header may be on a too-little-work chain
@ BLOCK_INVALID_HEADER
invalid proof of work or time too old
@ BLOCK_CACHED_INVALID
this block was cached as being invalid and we didn't store the reason why
@ BLOCK_CONSENSUS
invalid by consensus rules (excluding any below reasons)
@ BLOCK_MISSING_PREV
We don't have the previous block the checked one is built on.
@ BLOCK_INVALID_PREV
A block this one builds on is invalid.
@ BLOCK_MUTATED
the block's data didn't match the data committed to by the PoW
@ BLOCK_TIME_FUTURE
block timestamp was > 2 hours in the future (or our clock is bad)
int GetWitnessCommitmentIndex(const CBlock &block)
Compute at which vout of the block's coinbase transaction the witness commitment occurs,...
@ TX_MISSING_INPUTS
transaction was missing some of its inputs
@ TX_MEMPOOL_POLICY
violated mempool's fee/size/descendant/RBF/etc limits
@ TX_PREMATURE_SPEND
transaction spends a coinbase too early, or violates locktime/sequence locks
@ TX_INPUTS_NOT_STANDARD
inputs (covered by txid) failed policy rules
@ TX_WITNESS_STRIPPED
Transaction is missing a witness.
@ TX_CONFLICT
Tx already in mempool or conflicts with a tx in the chain (if it conflicts with another tx in mempool...
@ TX_NOT_STANDARD
otherwise didn't meet our local policy rules
@ TX_WITNESS_MUTATED
Transaction might have a witness prior to SegWit activation, or witness may have been malleated (whic...
@ TX_NO_MEMPOOL
this node does not have a mempool so can't validate the transaction
@ TX_CONSENSUS
invalid by consensus rules
@ TX_RECONSIDERABLE
fails some policy, but might be acceptable if submitted in a (different) package
static constexpr unsigned int LOCKTIME_VERIFY_SEQUENCE
Flags for nSequence and nLockTime locks.
static constexpr int64_t MAX_TIMEWARP
Maximum number of seconds that the timestamp of the first block of a difficulty adjustment period is ...
static const unsigned int MAX_BLOCK_WEIGHT
The maximum allowed weight for a block, see BIP 141 (network rule)
static const unsigned int MAX_BLOCK_SERIALIZED_SIZE
The maximum allowed size for a serialized block, in bytes (only for buffer size limits)
static const int64_t MAX_BLOCK_SIGOPS_COST
The maximum allowed number of signature check operations in a block (network rule)
static const int COINBASE_MATURITY
Coinbase transaction outputs can only be spent after this number of new blocks (network rule)
static const int WITNESS_SCALE_FACTOR
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
bool DestroyDB(const std::string &path_str)
bool DeploymentActiveAfter(const CBlockIndex *pindexPrev, const Consensus::Params ¶ms, Consensus::BuriedDeployment dep, VersionBitsCache &versionbitscache)
Determine if a deployment is active for the next block.
bool DeploymentActiveAt(const CBlockIndex &index, const Consensus::Params ¶ms, Consensus::BuriedDeployment dep, VersionBitsCache &versionbitscache)
Determine if a deployment is active for this block.
static const unsigned int MAX_DISCONNECTED_TX_POOL_BYTES
Maximum bytes for transactions to store for processing during reorg.
bool CheckEphemeralSpends(const Package &package, CFeeRate dust_relay_rate, const CTxMemPool &tx_pool, TxValidationState &out_child_state, Wtxid &out_child_wtxid)
Must be called for each transaction(package) if any dust is in the package.
bool PreCheckEphemeralTx(const CTransaction &tx, CFeeRate dust_relay_rate, CAmount base_fee, CAmount mod_fee, TxValidationState &state)
These utility functions ensure that ephemeral dust is safely created and spent without unduly risking...
static bool exists(const path &p)
static std::string PathToString(const path &path)
Convert path object to a byte string.
bool CheckDiskSpace(const fs::path &dir, uint64_t additional_bytes)
bool VerifyScript(const CScript &scriptSig, const CScript &scriptPubKey, const CScriptWitness *witness, script_verify_flags flags, const BaseSignatureChecker &checker, ScriptError *serror)
@ SCRIPT_VERIFY_NULLDUMMY
@ SCRIPT_VERIFY_CHECKSEQUENCEVERIFY
@ SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY
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 script_verify_flags STANDARD_SCRIPT_VERIFY_FLAGS
Standard script verification flags that standard transactions will comply with.
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 script_verify_flags 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.
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
std::map< uint256, script_verify_flags > script_flag_exceptions
Hashes of blocks that.
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, script_verify_flags 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.
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).
script_verify_flags GetBlockScriptFlags(const CBlockIndex &block_index, const ChainstateManager &chainman)
std::optional< LockPoints > CalculateLockPointsAtTip(CBlockIndex *tip, const CCoinsView &coins_view, const CTransaction &tx)
bool CheckInputScripts(const CTransaction &tx, TxValidationState &state, const CCoinsViewCache &inputs, script_verify_flags 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 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 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 bool CheckInputsFromMempoolAndCache(const CTransaction &tx, TxValidationState &state, const CCoinsViewCache &view, const CTxMemPool &pool, script_verify_flags 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 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.