96 "level 0 reads the blocks from disk",
97 "level 1 verifies block validity",
98 "level 2 verifies undo data",
99 "level 3 checks disconnection of tip blocks",
100 "level 4 tries to reconnect the blocks",
101 "each level includes the checks of the previous levels",
138 std::vector<CScriptCheck>* pvChecks =
nullptr)
151 const int nBlockHeight = active_chain_tip.nHeight + 1;
158 const int64_t nBlockTime{active_chain_tip.GetMedianTimePast()};
160 return IsFinalTx(tx, nBlockHeight, nBlockTime);
174 std::optional<std::vector<int>> CalculatePrevHeights(
179 std::vector<int> prev_heights;
180 prev_heights.resize(tx.
vin.size());
181 for (
size_t i = 0; i < tx.
vin.size(); ++i) {
190 prev_heights[i] = tip.
nHeight + 1;
192 prev_heights[i] = coin.
nHeight;
206 auto prev_heights{CalculatePrevHeights(*tip, coins_view, tx)};
207 if (!prev_heights.has_value())
return std::nullopt;
210 next_tip.
pprev = tip;
228 int max_input_height{0};
229 for (
const int height : prev_heights.value()) {
231 if (height != next_tip.
nHeight) {
232 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<uint256> 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;
473 const bool m_package_submission;
477 const bool m_package_feerates;
482 const std::optional<CFeeRate> m_client_maxfeerate;
485 const bool m_allow_carveouts;
488 static ATMPArgs SingleAccept(
const CChainParams& chainparams, int64_t accept_time,
489 bool bypass_limits, std::vector<COutPoint>& coins_to_uncache,
491 return ATMPArgs{ chainparams,
506 static ATMPArgs PackageTestAccept(
const CChainParams& chainparams, int64_t accept_time,
507 std::vector<COutPoint>& coins_to_uncache) {
508 return ATMPArgs{ chainparams,
523 static ATMPArgs PackageChildWithParents(
const CChainParams& chainparams, int64_t accept_time,
524 std::vector<COutPoint>& coins_to_uncache,
const std::optional<CFeeRate>& client_maxfeerate) {
525 return ATMPArgs{ chainparams,
540 static ATMPArgs SingleInPackageAccept(
const ATMPArgs& package_args) {
541 return ATMPArgs{ package_args.m_chainparams,
542 package_args.m_accept_time,
544 package_args.m_coins_to_uncache,
545 package_args.m_test_accept,
550 package_args.m_client_maxfeerate,
561 std::vector<COutPoint>& coins_to_uncache,
563 bool allow_replacement,
564 bool allow_sibling_eviction,
565 bool package_submission,
566 bool package_feerates,
567 std::optional<CFeeRate> client_maxfeerate,
568 bool allow_carveouts)
569 : m_chainparams{chainparams},
570 m_accept_time{accept_time},
571 m_bypass_limits{bypass_limits},
572 m_coins_to_uncache{coins_to_uncache},
573 m_test_accept{test_accept},
574 m_allow_replacement{allow_replacement},
575 m_allow_sibling_eviction{allow_sibling_eviction},
576 m_package_submission{package_submission},
577 m_package_feerates{package_feerates},
578 m_client_maxfeerate{client_maxfeerate},
579 m_allow_carveouts{allow_carveouts}
583 if (m_package_feerates) {
584 Assume(m_package_submission);
585 Assume(!m_allow_carveouts);
586 Assume(!m_allow_sibling_eviction);
588 if (m_allow_sibling_eviction)
Assume(m_allow_replacement);
628 explicit Workspace(
const CTransactionRef& ptx) : m_ptx(ptx), m_hash(ptx->GetHash()) {}
631 std::set<Txid> m_conflicts;
639 std::unique_ptr<CTxMemPoolEntry> m_entry;
642 bool m_sibling_eviction{
false};
677 bool PackageMempoolChecks(
const std::vector<CTransactionRef>& txns,
678 std::vector<Workspace>& workspaces,
701 std::map<uint256, MempoolAcceptResult>& results)
709 CAmount mempoolRejectFee = m_pool.GetMinFee().GetFee(package_size);
710 if (mempoolRejectFee > 0 && package_fee < mempoolRejectFee) {
714 if (package_fee < m_pool.m_opts.min_relay_feerate.GetFee(package_size)) {
716 strprintf(
"%d < %d", package_fee, m_pool.m_opts.min_relay_feerate.GetFee(package_size)));
723 return m_active_chainstate.m_chainman.m_validation_cache;
736 struct SubPackageState {
738 CAmount m_total_modified_fees{0};
740 int64_t m_total_vsize{0};
749 std::list<CTransactionRef> m_replaced_transactions;
754 size_t m_conflicting_size{0};
757 struct SubPackageState m_subpackage;
762 m_subpackage = SubPackageState{};
765 CleanupTemporaryCoins();
769 bool MemPoolAccept::PreChecks(ATMPArgs&
args, Workspace& ws)
775 const Txid& hash = ws.m_hash;
778 const int64_t nAcceptTime =
args.m_accept_time;
779 const bool bypass_limits =
args.m_bypass_limits;
780 std::vector<COutPoint>& coins_to_uncache =
args.m_coins_to_uncache;
784 std::unique_ptr<CTxMemPoolEntry>& entry = ws.m_entry;
796 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)) {
824 if (ptxConflicting) {
825 if (!
args.m_allow_replacement) {
829 if (!ws.m_conflicts.count(ptxConflicting->
GetHash()))
848 ws.m_conflicts.insert(ptxConflicting->
GetHash());
853 m_view.SetBackend(m_viewmempool);
859 coins_to_uncache.push_back(txin.
prevout);
865 if (!m_view.HaveCoin(txin.
prevout)) {
880 m_view.GetBestBlock();
885 m_view.SetBackend(m_dummy);
887 assert(m_active_chainstate.m_blockman.LookupBlockIndex(m_view.GetBestBlock()) == m_active_chainstate.m_chain.Tip());
894 const std::optional<LockPoints> lock_points{
CalculateLockPointsAtTip(m_active_chainstate.m_chain.Tip(), m_view, tx)};
916 ws.m_modified_fees = ws.m_base_fees;
917 m_pool.ApplyDelta(hash, ws.m_modified_fees);
921 bool fSpendsCoinbase =
false;
923 const Coin &coin = m_view.AccessCoin(txin.
prevout);
925 fSpendsCoinbase =
true;
932 const uint64_t entry_sequence = bypass_limits ? 0 : m_pool.GetSequence();
933 entry.reset(
new CTxMemPoolEntry(ptx, ws.m_base_fees, nAcceptTime, m_active_chainstate.m_chain.Height(), entry_sequence,
934 fSpendsCoinbase, nSigOpsCost, lock_points.value()));
935 ws.m_vsize = entry->GetTxSize();
947 if (!bypass_limits && ws.m_ptx->version !=
TRUC_VERSION && ws.m_modified_fees < m_pool.m_opts.min_relay_feerate.GetFee(ws.m_vsize)) {
951 strprintf(
"%d < %d", ws.m_modified_fees, m_pool.m_opts.min_relay_feerate.GetFee(ws.m_vsize)));
956 if (!bypass_limits && !
args.m_package_feerates && !
CheckFeeRate(ws.m_vsize, ws.m_modified_fees, state))
return false;
958 ws.m_iters_conflicting = m_pool.GetIterSet(ws.m_conflicts);
965 if (ws.m_conflicts.size() == 1 &&
args.m_allow_carveouts) {
993 assert(ws.m_iters_conflicting.size() == 1);
1000 if (
auto ancestors{m_pool.CalculateMemPoolAncestors(*entry, maybe_rbf_limits)}) {
1001 ws.m_ancestors = std::move(*ancestors);
1007 if (!
args.m_allow_carveouts) {
1032 if (
auto ancestors_retry{m_pool.CalculateMemPoolAncestors(*entry, cpfp_carve_out_limits)}) {
1033 ws.m_ancestors = std::move(*ancestors_retry);
1042 if (
const auto err{
SingleTRUCChecks(ws.m_ptx, ws.m_ancestors, ws.m_conflicts, ws.m_vsize)}) {
1044 if (
args.m_allow_sibling_eviction && err->second !=
nullptr) {
1050 ws.m_conflicts.insert(err->second->GetHash());
1054 ws.m_iters_conflicting.insert(m_pool.GetIter(err->second->GetHash()).value());
1055 ws.m_sibling_eviction =
true;
1076 m_subpackage.m_rbf |= !ws.m_conflicts.empty();
1080 bool MemPoolAccept::ReplacementChecks(Workspace& ws)
1086 const uint256& hash = ws.m_hash;
1089 CFeeRate newFeeRate(ws.m_modified_fees, ws.m_vsize);
1103 strprintf(
"insufficient fee%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1107 if (
const auto err_string{
GetEntriesForConflicts(tx, m_pool, ws.m_iters_conflicting, m_subpackage.m_all_conflicts)}) {
1109 strprintf(
"too many potential replacements%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1112 if (
const auto err_string{
HasNoNewUnconfirmed(tx, m_pool, m_subpackage.m_all_conflicts)}) {
1114 Assume(!ws.m_sibling_eviction);
1116 strprintf(
"replacement-adds-unconfirmed%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1122 m_subpackage.m_conflicting_fees += it->GetModifiedFee();
1123 m_subpackage.m_conflicting_size += it->GetTxSize();
1125 if (
const auto err_string{
PaysForRBF(m_subpackage.m_conflicting_fees, ws.m_modified_fees, ws.m_vsize,
1126 m_pool.m_opts.incremental_relay_feerate, hash)}) {
1129 strprintf(
"insufficient fee%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1134 bool MemPoolAccept::PackageMempoolChecks(
const std::vector<CTransactionRef>& txns,
1135 std::vector<Workspace>& workspaces,
1136 const int64_t total_vsize,
1143 assert(std::all_of(txns.cbegin(), txns.cend(), [
this](
const auto& tx)
1144 { return !m_pool.exists(GenTxid::Txid(tx->GetHash()));}));
1146 assert(txns.size() == workspaces.size());
1148 auto result = m_pool.CheckPackageLimits(txns, total_vsize);
1155 if (!m_subpackage.m_rbf)
return true;
1166 for (
const auto& ws : workspaces) {
1167 if (!ws.m_ancestors.empty()) {
1174 for (Workspace& ws : workspaces) {
1176 direct_conflict_iters.merge(ws.m_iters_conflicting);
1179 const auto& parent_ws = workspaces[0];
1180 const auto& child_ws = workspaces[1];
1185 m_subpackage.m_all_conflicts)}) {
1187 "package RBF failed: too many potential replacements", *err_string);
1191 m_subpackage.m_conflicting_fees += it->GetModifiedFee();
1192 m_subpackage.m_conflicting_size += it->GetTxSize();
1196 const Txid& child_hash = child_ws.m_ptx->GetHash();
1197 if (
const auto err_string{
PaysForRBF(m_subpackage.m_conflicting_fees,
1198 m_subpackage.m_total_modified_fees,
1199 m_subpackage.m_total_vsize,
1200 m_pool.m_opts.incremental_relay_feerate, child_hash)}) {
1202 "package RBF failed: insufficient anti-DoS fees", *err_string);
1207 const CFeeRate parent_feerate(parent_ws.m_modified_fees, parent_ws.m_vsize);
1208 const CFeeRate package_feerate(m_subpackage.m_total_modified_fees, m_subpackage.m_total_vsize);
1209 if (package_feerate <= parent_feerate) {
1211 "package RBF failed: package feerate is less than or equal to parent feerate",
1212 strprintf(
"package feerate %s <= parent feerate is %s", package_feerate.ToString(), parent_feerate.ToString()));
1217 if (
const auto err_tup{
ImprovesFeerateDiagram(m_pool, direct_conflict_iters, m_subpackage.m_all_conflicts, m_subpackage.m_total_modified_fees, m_subpackage.m_total_vsize)}) {
1219 "package RBF failed: " + err_tup.value().second,
"");
1223 txns.front()->GetHash().ToString(), txns.front()->GetWitnessHash().ToString(),
1224 txns.back()->GetHash().ToString(), txns.back()->GetWitnessHash().ToString());
1230 bool MemPoolAccept::PolicyScriptChecks(
const ATMPArgs&
args, Workspace& ws)
1241 if (!
CheckInputScripts(tx, state, m_view, scriptVerifyFlags,
true,
false, ws.m_precomputed_txdata, GetValidationCache())) {
1258 bool MemPoolAccept::ConsensusScriptChecks(
const ATMPArgs&
args, Workspace& ws)
1263 const uint256& hash = ws.m_hash;
1281 unsigned int currentBlockScriptVerifyFlags{
GetBlockScriptFlags(*m_active_chainstate.m_chain.Tip(), m_active_chainstate.m_chainman)};
1283 ws.m_precomputed_txdata, m_active_chainstate.CoinsTip(), GetValidationCache())) {
1284 LogPrintf(
"BUG! PLEASE REPORT THIS! CheckInputScripts failed against latest-block but not STANDARD flags %s, %s\n", hash.
ToString(), state.
ToString());
1291 bool MemPoolAccept::Finalize(
const ATMPArgs&
args, Workspace& ws)
1296 const uint256& hash = ws.m_hash;
1298 const bool bypass_limits =
args.m_bypass_limits;
1299 std::unique_ptr<CTxMemPoolEntry>& entry = ws.m_entry;
1301 if (!m_subpackage.m_all_conflicts.empty())
Assume(
args.m_allow_replacement);
1305 LogPrint(
BCLog::MEMPOOL,
"replacing mempool tx %s (wtxid=%s, fees=%s, vsize=%s). New tx %s (wtxid=%s, fees=%s, vsize=%s)\n",
1306 it->GetTx().GetHash().ToString(),
1307 it->GetTx().GetWitnessHash().ToString(),
1313 entry->GetTxSize());
1314 TRACE7(mempool, replaced,
1315 it->GetTx().GetHash().data(),
1318 std::chrono::duration_cast<std::chrono::duration<std::uint64_t>>(it->GetTime()).count(),
1323 m_subpackage.m_replaced_transactions.push_back(it->GetSharedTx());
1328 m_subpackage.m_all_conflicts.clear();
1330 m_pool.addUnchecked(*entry, ws.m_ancestors);
1336 if (!
args.m_package_submission && !bypass_limits) {
1345 bool MemPoolAccept::SubmitPackage(
const ATMPArgs&
args, std::vector<Workspace>& workspaces,
1347 std::map<uint256, MempoolAcceptResult>& results)
1353 assert(std::all_of(workspaces.cbegin(), workspaces.cend(), [
this](
const auto& ws){
1354 return !m_pool.exists(GenTxid::Txid(ws.m_ptx->GetHash())); }));
1356 bool all_submitted =
true;
1361 for (Workspace& ws : workspaces) {
1362 if (!ConsensusScriptChecks(
args, ws)) {
1366 all_submitted =
false;
1368 strprintf(
"BUG! PolicyScriptChecks succeeded but ConsensusScriptChecks failed: %s",
1369 ws.m_ptx->GetHash().ToString()));
1375 auto ancestors{m_pool.CalculateMemPoolAncestors(*ws.m_entry, m_pool.m_opts.limits)};
1380 all_submitted =
false;
1382 strprintf(
"BUG! Mempool ancestors or descendants were underestimated: %s",
1383 ws.m_ptx->GetHash().ToString()));
1385 ws.m_ancestors = std::move(ancestors).value_or(ws.m_ancestors);
1392 if (!Finalize(
args, ws)) {
1396 all_submitted =
false;
1398 strprintf(
"BUG! Adding to mempool failed: %s", ws.m_ptx->GetHash().ToString()));
1402 std::vector<Wtxid> all_package_wtxids;
1403 all_package_wtxids.reserve(workspaces.size());
1404 std::transform(workspaces.cbegin(), workspaces.cend(), std::back_inserter(all_package_wtxids),
1405 [](
const auto& ws) { return ws.m_ptx->GetWitnessHash(); });
1407 if (!m_subpackage.m_replaced_transactions.empty()) {
1408 LogPrint(
BCLog::MEMPOOL,
"replaced %u mempool transactions with %u new one(s) for %s additional fees, %d delta bytes\n",
1409 m_subpackage.m_replaced_transactions.size(), workspaces.size(),
1410 m_subpackage.m_total_modified_fees - m_subpackage.m_conflicting_fees,
1411 m_subpackage.m_total_vsize -
static_cast<int>(m_subpackage.m_conflicting_size));
1415 for (Workspace& ws : workspaces) {
1416 const auto effective_feerate =
args.m_package_feerates ? ws.m_package_feerate :
1417 CFeeRate{ws.m_modified_fees,
static_cast<uint32_t
>(ws.m_vsize)};
1418 const auto effective_feerate_wtxids =
args.m_package_feerates ? all_package_wtxids :
1419 std::vector<Wtxid>{ws.m_ptx->GetWitnessHash()};
1420 results.emplace(ws.m_ptx->GetWitnessHash(),
1422 ws.m_base_fees, effective_feerate, effective_feerate_wtxids));
1423 if (!m_pool.m_opts.signals)
continue;
1426 ws.m_vsize, ws.m_entry->GetHeight(),
1427 args.m_bypass_limits,
args.m_package_submission,
1429 m_pool.HasNoInputsOf(tx));
1430 m_pool.m_opts.signals->TransactionAddedToMempool(tx_info, m_pool.GetAndIncrementSequence());
1432 return all_submitted;
1441 const std::vector<Wtxid> single_wtxid{ws.m_ptx->GetWitnessHash()};
1443 if (!PreChecks(
args, ws)) {
1452 if (
args.m_client_maxfeerate &&
CFeeRate(ws.m_modified_fees, ws.m_vsize) >
args.m_client_maxfeerate.value()) {
1457 if (m_subpackage.m_rbf && !ReplacementChecks(ws)) {
1471 const CFeeRate effective_feerate{ws.m_modified_fees,
static_cast<uint32_t
>(ws.m_vsize)};
1473 if (
args.m_test_accept) {
1475 ws.m_base_fees, effective_feerate, single_wtxid);
1478 if (!Finalize(
args, ws)) {
1485 if (m_pool.m_opts.signals) {
1488 ws.m_vsize, ws.m_entry->GetHeight(),
1489 args.m_bypass_limits,
args.m_package_submission,
1491 m_pool.HasNoInputsOf(tx));
1492 m_pool.m_opts.signals->TransactionAddedToMempool(tx_info, m_pool.GetAndIncrementSequence());
1495 if (!m_subpackage.m_replaced_transactions.empty()) {
1496 LogPrint(
BCLog::MEMPOOL,
"replaced %u mempool transactions with 1 new transaction for %s additional fees, %d delta bytes\n",
1497 m_subpackage.m_replaced_transactions.size(),
1498 ws.m_modified_fees - m_subpackage.m_conflicting_fees,
1499 ws.m_vsize -
static_cast<int>(m_subpackage.m_conflicting_size));
1503 effective_feerate, single_wtxid);
1514 std::vector<Workspace> workspaces{};
1515 workspaces.reserve(txns.size());
1516 std::transform(txns.cbegin(), txns.cend(), std::back_inserter(workspaces),
1517 [](
const auto& tx) { return Workspace(tx); });
1518 std::map<uint256, MempoolAcceptResult> results;
1523 for (Workspace& ws : workspaces) {
1524 if (!PreChecks(
args, ws)) {
1533 if (
args.m_client_maxfeerate &&
CFeeRate(ws.m_modified_fees, ws.m_vsize) >
args.m_client_maxfeerate.value()) {
1551 m_viewmempool.PackageAddTransaction(ws.m_ptx);
1556 for (Workspace& ws : workspaces) {
1572 m_subpackage.m_total_vsize = std::accumulate(workspaces.cbegin(), workspaces.cend(), int64_t{0},
1573 [](int64_t
sum,
auto& ws) { return sum + ws.m_vsize; });
1574 m_subpackage.m_total_modified_fees = std::accumulate(workspaces.cbegin(), workspaces.cend(),
CAmount{0},
1575 [](
CAmount sum,
auto& ws) { return sum + ws.m_modified_fees; });
1576 const CFeeRate package_feerate(m_subpackage.m_total_modified_fees, m_subpackage.m_total_vsize);
1577 std::vector<Wtxid> all_package_wtxids;
1578 all_package_wtxids.reserve(workspaces.size());
1579 std::transform(workspaces.cbegin(), workspaces.cend(), std::back_inserter(all_package_wtxids),
1580 [](
const auto& ws) { return ws.m_ptx->GetWitnessHash(); });
1582 if (
args.m_package_feerates &&
1583 !
CheckFeeRate(m_subpackage.m_total_vsize, m_subpackage.m_total_modified_fees, placeholder_state)) {
1591 if (txns.size() > 1 && !PackageMempoolChecks(txns, workspaces, m_subpackage.m_total_vsize, package_state)) {
1595 for (Workspace& ws : workspaces) {
1596 ws.m_package_feerate = package_feerate;
1597 if (!PolicyScriptChecks(
args, ws)) {
1603 if (
args.m_test_accept) {
1604 const auto effective_feerate =
args.m_package_feerates ? ws.m_package_feerate :
1605 CFeeRate{ws.m_modified_fees,
static_cast<uint32_t
>(ws.m_vsize)};
1606 const auto effective_feerate_wtxids =
args.m_package_feerates ? all_package_wtxids :
1607 std::vector<Wtxid>{ws.m_ptx->GetWitnessHash()};
1608 results.emplace(ws.m_ptx->GetWitnessHash(),
1610 ws.m_vsize, ws.m_base_fees, effective_feerate,
1611 effective_feerate_wtxids));
1617 if (!SubmitPackage(
args, workspaces, package_state, results)) {
1625 void MemPoolAccept::CleanupTemporaryCoins()
1645 for (
const auto& outpoint : m_viewmempool.GetNonBaseCoins()) {
1648 m_view.Uncache(outpoint);
1651 m_viewmempool.Reset();
1659 if (subpackage.size() > 1) {
1660 return AcceptMultipleTransactions(subpackage,
args);
1662 const auto& tx = subpackage.front();
1663 ATMPArgs single_args = ATMPArgs::SingleInPackageAccept(
args);
1664 const auto single_res = AcceptSingleTransaction(tx, single_args);
1675 ClearSubPackageState();
1702 assert(package.size() > 1);
1705 const auto& child = package.back();
1706 std::unordered_set<uint256, SaltedTxidHasher> unconfirmed_parent_txids;
1707 std::transform(package.cbegin(), package.cend() - 1,
1708 std::inserter(unconfirmed_parent_txids, unconfirmed_parent_txids.end()),
1709 [](
const auto& tx) { return tx->GetHash(); });
1716 const CCoinsViewCache& coins_tip_cache = m_active_chainstate.CoinsTip();
1717 for (
const auto& input : child->vin) {
1719 args.m_coins_to_uncache.push_back(input.prevout);
1725 m_view.SetBackend(m_active_chainstate.CoinsTip());
1726 const auto package_or_confirmed = [
this, &unconfirmed_parent_txids](
const auto& input) {
1727 return unconfirmed_parent_txids.count(input.prevout.hash) > 0 || m_view.HaveCoin(input.prevout);
1729 if (!std::all_of(child->vin.cbegin(), child->vin.cend(), package_or_confirmed)) {
1735 m_view.SetBackend(m_dummy);
1740 std::map<uint256, MempoolAcceptResult> results_final;
1744 std::map<uint256, MempoolAcceptResult> individual_results_nonfinal;
1745 bool quit_early{
false};
1746 std::vector<CTransactionRef> txns_package_eval;
1747 for (
const auto& tx : package) {
1749 const auto& txid = tx->
GetHash();
1763 const auto& entry{*
Assert(m_pool.GetEntry(txid))};
1773 const auto& entry{*
Assert(m_pool.GetEntry(txid))};
1779 const auto single_package_res = AcceptSubPackage({tx},
args);
1780 const auto& single_res = single_package_res.m_tx_results.at(wtxid);
1785 results_final.emplace(wtxid, single_res);
1799 individual_results_nonfinal.emplace(wtxid, single_res);
1801 individual_results_nonfinal.emplace(wtxid, single_res);
1802 txns_package_eval.push_back(tx);
1807 auto multi_submission_result = quit_early || txns_package_eval.empty() ?
PackageMempoolAcceptResult(package_state_quit_early, {}) :
1808 AcceptSubPackage(txns_package_eval,
args);
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);
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)
1876 TRACE2(mempool, rejected,
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) {}
1936 void 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) {}
1956 return m_cached_snapshot_base;
1959 void Chainstate::InitCoinsDB(
1960 size_t cache_size_bytes,
1972 .cache_bytes = cache_size_bytes,
1973 .memory_only = in_memory,
1974 .wipe_data = should_wipe,
1980 void Chainstate::InitCoinsCache(
size_t cache_size_bytes)
2006 if (chain.Tip() ==
nullptr) {
2015 LogPrintf(
"Leaving InitialBlockDownload (latching to false)\n");
2031 LogPrintf(
"%s: Warning: Found invalid chain at least ~6 blocks longer than our best chain.\nChain state database corruption likely.\n", __func__);
2034 _(
"Warning: We do not appear to fully agree with our peers! You may need to upgrade, or other nodes may need to upgrade."));
2051 LogPrintf(
"%s: invalid block=%s height=%d log2_work=%f date=%s\n", __func__,
2056 LogPrintf(
"%s: current best=%s height=%d log2_work=%f date=%s\n", __func__,
2094 return VerifyScript(scriptSig,
m_tx_out.
scriptPubKey, witness,
nFlags,
CachingTransactionSignatureChecker(
ptxTo,
nIn,
m_tx_out.
nValue,
cacheStore, *
m_signature_cache, *
txdata), &
error);
2098 : m_signature_cache{signature_cache_bytes}
2109 LogPrintf(
"Using %zu MiB out of %zu MiB requested for script execution cache, able to store %zu elements\n",
2110 approx_size_bytes >> 20, script_execution_cache_bytes >> 20, num_elems);
2136 std::vector<CScriptCheck>* pvChecks)
2141 pvChecks->reserve(tx.
vin.size());
2158 std::vector<CTxOut> spent_outputs;
2159 spent_outputs.reserve(tx.
vin.size());
2161 for (
const auto& txin : tx.
vin) {
2165 spent_outputs.emplace_back(coin.
out);
2167 txdata.
Init(tx, std::move(spent_outputs));
2171 for (
unsigned int i = 0; i < tx.
vin.size(); i++) {
2182 pvChecks->emplace_back(std::move(check));
2183 }
else if (!check()) {
2211 if (cacheFullScriptStore && !pvChecks) {
2239 if (undo.nHeight == 0) {
2245 undo.nHeight = alternate.
nHeight;
2270 LogError(
"DisconnectBlock(): failure reading undo data\n");
2274 if (blockUndo.
vtxundo.size() + 1 != block.
vtx.size()) {
2275 LogError(
"DisconnectBlock(): block and undo data inconsistent\n");
2285 bool fEnforceBIP30 = !((pindex->
nHeight==91722 && pindex->
GetBlockHash() ==
uint256S(
"0x00000000000271a2dc26e7667f8419f2e15416dc6955e5a6c6cdf3f2574dd08e")) ||
2286 (pindex->
nHeight==91812 && pindex->
GetBlockHash() ==
uint256S(
"0x00000000000af0aed4792b1acee3d966af36cf5def14935db8de83d6f9306f2f")));
2289 for (
int i = block.
vtx.size() - 1; i >= 0; i--) {
2293 bool is_bip30_exception = (is_coinbase && !fEnforceBIP30);
2297 for (
size_t o = 0; o < tx.
vout.size(); o++) {
2298 if (!tx.
vout[o].scriptPubKey.IsUnspendable()) {
2303 if (!is_bip30_exception) {
2314 LogError(
"DisconnectBlock(): transaction and undo data inconsistent\n");
2317 for (
unsigned int j = tx.
vin.size(); j > 0;) {
2415 const auto time_start{SteadyClock::now()};
2431 if (!
CheckBlock(block, state, params.GetConsensus(), !fJustCheck, !fJustCheck)) {
2443 uint256 hashPrevBlock = pindex->
pprev ==
nullptr ?
uint256() : pindex->pprev->GetBlockHash();
2450 if (block_hash == params.GetConsensus().hashGenesisBlock) {
2456 bool fScriptChecks =
true;
2465 if (it->second.GetAncestor(pindex->
nHeight) == pindex &&
2487 const auto time_1{SteadyClock::now()};
2488 m_chainman.time_check += time_1 - time_start;
2490 Ticks<MillisecondsDouble>(time_1 - time_start),
2532 static constexpr
int BIP34_IMPLIES_BIP30_LIMIT = 1983702;
2564 fEnforceBIP30 = fEnforceBIP30 && (!pindexBIP34height || !(pindexBIP34height->
GetBlockHash() == params.GetConsensus().BIP34Hash));
2569 if (fEnforceBIP30 || pindex->
nHeight >= BIP34_IMPLIES_BIP30_LIMIT) {
2570 for (
const auto& tx : block.
vtx) {
2571 for (
size_t o = 0; o < tx->
vout.size(); o++) {
2573 LogPrintf(
"ERROR: ConnectBlock(): tried to overwrite transaction\n");
2581 int nLockTimeFlags = 0;
2589 const auto time_2{SteadyClock::now()};
2592 Ticks<MillisecondsDouble>(time_2 - time_1),
2604 std::vector<PrecomputedTransactionData> txsdata(block.
vtx.size());
2606 std::vector<int> prevheights;
2609 int64_t nSigOpsCost = 0;
2610 blockundo.
vtxundo.reserve(block.
vtx.size() - 1);
2611 for (
unsigned int i = 0; i < block.
vtx.size(); i++)
2615 nInputs += tx.
vin.size();
2630 LogPrintf(
"ERROR: %s: accumulated fee in the block out of range.\n", __func__);
2637 prevheights.resize(tx.
vin.size());
2638 for (
size_t j = 0; j < tx.
vin.size(); j++) {
2642 if (!
SequenceLocks(tx, nLockTimeFlags, prevheights, *pindex)) {
2643 LogPrintf(
"ERROR: %s: contains a non-BIP68-final transaction\n", __func__);
2654 LogPrintf(
"ERROR: ConnectBlock(): too many sigops\n");
2660 std::vector<CScriptCheck> vChecks;
2661 bool fCacheResults = fJustCheck;
2667 LogError(
"ConnectBlock(): CheckInputScripts on %s failed with %s\n",
2671 control.Add(std::move(vChecks));
2676 blockundo.
vtxundo.emplace_back();
2680 const auto time_3{SteadyClock::now()};
2682 LogPrint(
BCLog::BENCH,
" - Connect %u transactions: %.2fms (%.3fms/tx, %.3fms/txin) [%.2fs (%.2fms/blk)]\n", (
unsigned)block.
vtx.size(),
2683 Ticks<MillisecondsDouble>(time_3 - time_2), Ticks<MillisecondsDouble>(time_3 - time_2) / block.
vtx.size(),
2684 nInputs <= 1 ? 0 : Ticks<MillisecondsDouble>(time_3 - time_2) / (nInputs - 1),
2685 Ticks<SecondsDouble>(
m_chainman.time_connect),
2689 if (block.
vtx[0]->GetValueOut() > blockReward) {
2690 LogPrintf(
"ERROR: ConnectBlock(): coinbase pays too much (actual=%d vs limit=%d)\n", block.
vtx[0]->GetValueOut(), blockReward);
2694 if (!control.Wait()) {
2695 LogPrintf(
"ERROR: %s: CheckQueue failed\n", __func__);
2698 const auto time_4{SteadyClock::now()};
2700 LogPrint(
BCLog::BENCH,
" - Verify %u txins: %.2fms (%.3fms/txin) [%.2fs (%.2fms/blk)]\n", nInputs - 1,
2701 Ticks<MillisecondsDouble>(time_4 - time_2),
2702 nInputs <= 1 ? 0 : Ticks<MillisecondsDouble>(time_4 - time_2) / (nInputs - 1),
2703 Ticks<SecondsDouble>(
m_chainman.time_verify),
2709 if (!
m_blockman.WriteUndoDataForBlock(blockundo, state, *pindex)) {
2713 const auto time_5{SteadyClock::now()};
2716 Ticks<MillisecondsDouble>(time_5 - time_4),
2728 const auto time_6{SteadyClock::now()};
2731 Ticks<MillisecondsDouble>(time_6 - time_5),
2735 TRACE6(validation, block_connected,
2750 return this->GetCoinsCacheSizeState(
2756 size_t max_coins_cache_size_bytes,
2757 size_t max_mempool_size_bytes)
2762 int64_t nTotalSpace =
2763 max_coins_cache_size_bytes + std::max<int64_t>(int64_t(max_mempool_size_bytes) - nMempoolUsage, 0);
2766 static constexpr int64_t MAX_BLOCK_COINSDB_USAGE_BYTES = 10 * 1024 * 1024;
2767 int64_t large_threshold =
2768 std::max((9 * nTotalSpace) / 10, nTotalSpace - MAX_BLOCK_COINSDB_USAGE_BYTES);
2770 if (cacheSize > nTotalSpace) {
2771 LogPrintf(
"Cache size (%s) exceeds total space (%s)\n", cacheSize, nTotalSpace);
2773 }
else if (cacheSize > large_threshold) {
2779 bool Chainstate::FlushStateToDisk(
2782 int nManualPruneHeight)
2785 assert(this->CanFlushToDisk());
2786 std::set<int> setFilesToPrune;
2787 bool full_flush_completed =
false;
2794 bool fFlushForPrune =
false;
2795 bool fDoFullFlush =
false;
2803 std::optional<std::string> limiting_lock;
2805 for (
const auto& prune_lock :
m_blockman.m_prune_locks) {
2806 if (prune_lock.second.height_first == std::numeric_limits<int>::max())
continue;
2809 last_prune = std::max(1, std::min(last_prune, lock_height));
2810 if (last_prune == lock_height) {
2811 limiting_lock = prune_lock.first;
2815 if (limiting_lock) {
2816 LogPrint(
BCLog::PRUNE,
"%s limited pruning to height %d\n", limiting_lock.value(), last_prune);
2819 if (nManualPruneHeight > 0) {
2824 std::min(last_prune, nManualPruneHeight),
2832 if (!setFilesToPrune.empty()) {
2833 fFlushForPrune =
true;
2835 m_blockman.m_block_tree_db->WriteFlag(
"prunedblockfiles",
true);
2840 const auto nNow{SteadyClock::now()};
2857 fDoFullFlush = (mode ==
FlushStateMode::ALWAYS) || fCacheLarge || fCacheCritical || fPeriodicFlush || fFlushForPrune;
2859 if (fDoFullFlush || fPeriodicWrite) {
2884 if (fFlushForPrune) {
2892 if (fDoFullFlush && !
CoinsTip().GetBestBlock().IsNull()) {
2905 const auto empty_cache{(mode ==
FlushStateMode::ALWAYS) || fCacheLarge || fCacheCritical || fFlushForPrune};
2910 full_flush_completed =
true;
2912 int64_t{Ticks<std::chrono::microseconds>(SteadyClock::now() - nNow)},
2914 (uint64_t)coins_count,
2915 (uint64_t)coins_mem_usage,
2916 (
bool)fFlushForPrune);
2923 }
catch (
const std::runtime_error& e) {
2950 const std::string& func_name,
2951 const std::string&
prefix,
2956 LogPrintf(
"%s%s: new best=%s height=%d version=0x%08x log2_work=%f tx=%lu date='%s' progress=%f cache=%.1fMiB(%utxo)%s\n",
2964 !warning_messages.empty() ?
strprintf(
" warning='%s'", warning_messages) :
"");
2967 void Chainstate::UpdateTip(
const CBlockIndex* pindexNew)
2970 const auto& coins_tip = this->
CoinsTip();
2978 constexpr
int BACKGROUND_LOG_INTERVAL = 2000;
2979 if (pindexNew->
nHeight % BACKGROUND_LOG_INTERVAL == 0) {
2980 UpdateTipLog(coins_tip, pindexNew, params, __func__,
"[background validation] ",
"");
2996 std::vector<bilingual_str> warning_messages;
3007 warning_messages.push_back(warning);
3012 UpdateTipLog(coins_tip, pindexNew, params, __func__,
"",
3035 std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
3038 LogError(
"DisconnectTip(): Failed to read block\n");
3042 const auto time_start{SteadyClock::now()};
3046 if (DisconnectBlock(block, pindexDelete, view) !=
DISCONNECT_OK) {
3050 bool flushed = view.
Flush();
3054 Ticks<MillisecondsDouble>(SteadyClock::now() - time_start));
3058 const int max_height_first{pindexDelete->
nHeight - 1};
3059 for (
auto& prune_lock :
m_blockman.m_prune_locks) {
3060 if (prune_lock.second.height_first <= max_height_first)
continue;
3062 prune_lock.second.height_first = max_height_first;
3063 LogPrint(
BCLog::PRUNE,
"%s prune lock moved back to %d\n", prune_lock.first, max_height_first);
3082 UpdateTip(pindexDelete->
pprev);
3144 const auto time_1{SteadyClock::now()};
3145 std::shared_ptr<const CBlock> pthisBlock;
3147 std::shared_ptr<CBlock> pblockNew = std::make_shared<CBlock>();
3151 pthisBlock = pblockNew;
3154 pthisBlock = pblock;
3156 const CBlock& blockConnecting = *pthisBlock;
3158 const auto time_2{SteadyClock::now()};
3159 SteadyClock::time_point time_3;
3163 Ticks<MillisecondsDouble>(time_2 - time_1));
3166 bool rv =
ConnectBlock(blockConnecting, state, pindexNew, view);
3176 time_3 = SteadyClock::now();
3177 m_chainman.time_connect_total += time_3 - time_2;
3180 Ticks<MillisecondsDouble>(time_3 - time_2),
3181 Ticks<SecondsDouble>(
m_chainman.time_connect_total),
3183 bool flushed = view.
Flush();
3186 const auto time_4{SteadyClock::now()};
3189 Ticks<MillisecondsDouble>(time_4 - time_3),
3196 const auto time_5{SteadyClock::now()};
3197 m_chainman.time_chainstate += time_5 - time_4;
3199 Ticks<MillisecondsDouble>(time_5 - time_4),
3200 Ticks<SecondsDouble>(
m_chainman.time_chainstate),
3209 UpdateTip(pindexNew);
3211 const auto time_6{SteadyClock::now()};
3212 m_chainman.time_post_connect += time_6 - time_5;
3215 Ticks<MillisecondsDouble>(time_6 - time_5),
3216 Ticks<SecondsDouble>(
m_chainman.time_post_connect),
3219 Ticks<MillisecondsDouble>(time_6 - time_1),
3228 m_chainman.MaybeCompleteSnapshotValidation();
3256 bool fInvalidAncestor =
false;
3266 if (fFailedChain || fMissingData) {
3273 while (pindexTest != pindexFailed) {
3277 }
else if (fMissingData) {
3282 std::make_pair(pindexFailed->
pprev, pindexFailed));
3285 pindexFailed = pindexFailed->
pprev;
3288 fInvalidAncestor =
true;
3291 pindexTest = pindexTest->
pprev;
3293 if (!fInvalidAncestor)
3325 bool fBlocksDisconnected =
false;
3339 fBlocksDisconnected =
true;
3343 std::vector<CBlockIndex*> vpindexToConnect;
3344 bool fContinue =
true;
3349 int nTargetHeight = std::min(
nHeight + 32, pindexMostWork->
nHeight);
3350 vpindexToConnect.clear();
3351 vpindexToConnect.reserve(nTargetHeight -
nHeight);
3354 vpindexToConnect.push_back(pindexIter);
3355 pindexIter = pindexIter->
pprev;
3361 if (!
ConnectTip(state, pindexConnect, pindexConnect == pindexMostWork ? pblock : std::shared_ptr<const CBlock>(), connectTrace, disconnectpool)) {
3368 fInvalidFound =
true;
3389 if (fBlocksDisconnected) {
3410 bool fNotify =
false;
3411 bool fInitialBlockDownload =
false;
3415 pindexHeader = m_best_header;
3417 if (pindexHeader != m_last_notified_header) {
3420 m_last_notified_header = pindexHeader;
3433 if (signals.CallbacksPending() > 10) {
3434 signals.SyncWithValidationInterfaceQueue();
3438 bool Chainstate::ActivateBestChain(
BlockValidationState& state, std::shared_ptr<const CBlock> pblock)
3457 LogPrintf(
"m_disabled is set - this chainstate should not be in operation. "
3464 bool exited_ibd{
false};
3478 LOCK(MempoolMutex());
3481 bool blocks_connected =
false;
3487 if (pindexMostWork ==
nullptr) {
3492 if (pindexMostWork ==
nullptr || pindexMostWork ==
m_chain.
Tip()) {
3496 bool fInvalidFound =
false;
3497 std::shared_ptr<const CBlock> nullBlockPtr;
3498 if (!
ActivateBestChainStep(state, pindexMostWork, pblock && pblock->GetHash() == pindexMostWork->
GetBlockHash() ? pblock : nullBlockPtr, fInvalidFound, connectTrace)) {
3502 blocks_connected =
true;
3504 if (fInvalidFound) {
3506 pindexMostWork =
nullptr;
3511 assert(trace.pblock && trace.pindex);
3526 if (!blocks_connected)
return true;
3531 if (was_in_ibd && !still_in_ibd) {
3588 }
while (pindexNewTip != pindexMostWork);
3628 return ActivateBestChain(state, std::shared_ptr<const CBlock>());
3638 if (pindex->
nHeight == 0)
return false;
3641 bool pindex_was_in_chain =
false;
3642 int disconnected = 0;
3656 std::multimap<const arith_uint256, CBlockIndex *> candidate_blocks_by_work;
3660 for (
auto& entry :
m_blockman.m_block_index) {
3671 candidate_blocks_by_work.insert(std::make_pair(candidate->
nChainWork, candidate));
3686 LOCK(MempoolMutex());
3688 pindex_was_in_chain =
true;
3701 if (!
ret)
return false;
3721 auto candidate_it = candidate_blocks_by_work.lower_bound(invalid_walk_tip->
pprev->
nChainWork);
3722 while (candidate_it != candidate_blocks_by_work.end()) {
3725 candidate_it = candidate_blocks_by_work.erase(candidate_it);
3733 to_mark_failed = invalid_walk_tip;
3758 for (
auto& [
_, block_index] :
m_blockman.m_block_index) {
3768 if (pindex_was_in_chain) {
3793 for (
auto& [
_, block_index] :
m_blockman.m_block_index) {
3794 if (!block_index.IsValid() && block_index.GetAncestor(
nHeight) == pindex) {
3800 if (&block_index ==
m_chainman.m_best_invalid) {
3809 while (pindex !=
nullptr) {
3815 pindex = pindex->
pprev;
3829 if (is_active_chainstate) {
3833 }
else if (!m_disabled) {
3838 if (snapshot_base->GetAncestor(pindex->
nHeight) == pindex) {
3848 pindexNew->
nTx = block.
vtx.size();
3854 auto prev_tx_sum = [](
CBlockIndex& block) {
return block.nTx + (block.pprev ? block.pprev->nChainTx : 0); };
3856 pindexNew == GetSnapshotBaseBlock())) {
3857 LogWarning(
"Internal bug detected: block %d has unexpected nChainTx %i that should be %i (%s %s). Please report this issue here: %s\n",
3861 pindexNew->nFile = pos.
nFile;
3862 pindexNew->nDataPos = pos.
nPos;
3863 pindexNew->nUndoPos = 0;
3873 std::deque<CBlockIndex*> queue;
3874 queue.push_back(pindexNew);
3877 while (!queue.empty()) {
3885 LogWarning(
"Internal bug detected: block %d has unexpected nChainTx %i that should be %i (%s %s). Please report this issue here: %s\n",
3888 pindex->
nChainTx = prev_tx_sum(*pindex);
3891 c->TryAddBlockIndexCandidate(pindex);
3893 std::pair<std::multimap<CBlockIndex*, CBlockIndex*>::iterator, std::multimap<CBlockIndex*, CBlockIndex*>::iterator> range =
m_blockman.
m_blocks_unlinked.equal_range(pindex);
3894 while (range.first != range.second) {
3895 std::multimap<CBlockIndex*, CBlockIndex*>::iterator it = range.first;
3896 queue.push_back(it->second);
3927 "hashMerkleRoot mismatch");
3936 "bad-txns-duplicate",
3937 "duplicate transaction");
3952 if (expect_witness_commitment) {
3957 assert(!block.
vtx.empty() && !block.
vtx[0]->vin.empty());
3958 const auto& witness_stack{block.
vtx[0]->vin[0].scriptWitness.stack};
3960 if (witness_stack.size() != 1 || witness_stack[0].size() != 32) {
3963 "bad-witness-nonce-size",
3964 strprintf(
"%s : invalid witness reserved value size", __func__));
3973 if (memcmp(hash_witness.
begin(), &block.
vtx[0]->vout[commitpos].scriptPubKey[6], 32)) {
3976 "bad-witness-merkle-match",
3977 strprintf(
"%s : witness merkle commitment mismatch", __func__));
3986 for (
const auto& tx : block.
vtx) {
3990 "unexpected-witness",
3991 strprintf(
"%s : unexpected witness data found", __func__));
4031 if (block.
vtx.empty() || !block.
vtx[0]->IsCoinBase())
4033 for (
unsigned int i = 1; i < block.
vtx.size(); i++)
4034 if (block.
vtx[i]->IsCoinBase())
4039 for (
const auto& tx : block.
vtx) {
4049 unsigned int nSigOps = 0;
4050 for (
const auto& tx : block.
vtx)
4057 if (fCheckPOW && fCheckMerkleRoot)
4063 void ChainstateManager::UpdateUncommittedBlockStructures(
CBlock& block,
const CBlockIndex* pindexPrev)
const
4066 static const std::vector<unsigned char>
nonce(32, 0x00);
4069 tx.
vin[0].scriptWitness.stack.resize(1);
4070 tx.
vin[0].scriptWitness.stack[0] =
nonce;
4077 std::vector<unsigned char> commitment;
4079 std::vector<unsigned char>
ret(32, 0x00);
4087 out.scriptPubKey[1] = 0x24;
4088 out.scriptPubKey[2] = 0xaa;
4089 out.scriptPubKey[3] = 0x21;
4090 out.scriptPubKey[4] = 0xa9;
4091 out.scriptPubKey[5] = 0xed;
4092 memcpy(&
out.scriptPubKey[6], witnessroot.
begin(), 32);
4093 commitment = std::vector<unsigned char>(
out.scriptPubKey.begin(),
out.scriptPubKey.end());
4098 UpdateUncommittedBlockStructures(block, pindexPrev);
4104 return std::all_of(headers.cbegin(), headers.cend(),
4105 [&](
const auto& header) { return CheckProofOfWork(header.GetHash(), header.nBits, consensusParams);});
4116 if (block.
vtx.empty() || !block.
vtx[0]->IsCoinBase()) {
4123 return std::any_of(block.
vtx.begin(), block.
vtx.end(),
4124 [](
auto& tx) { return GetSerializeSize(TX_NO_WITNESS(tx)) == 64; });
4161 assert(pindexPrev !=
nullptr);
4170 if (chainman.m_options.checkpoints_enabled) {
4174 const CBlockIndex* pcheckpoint = blockman.GetLastCheckpoint(chainman.GetParams().Checkpoints());
4175 if (pcheckpoint && nHeight < pcheckpoint->
nHeight) {
4176 LogPrintf(
"ERROR: %s: forked chain older than last checkpoint (height %d)\n", __func__,
nHeight);
4209 const int nHeight = pindexPrev ==
nullptr ? 0 : pindexPrev->
nHeight + 1;
4212 bool enforce_locktime_median_time_past{
false};
4214 assert(pindexPrev !=
nullptr);
4215 enforce_locktime_median_time_past =
true;
4218 const int64_t nLockTimeCutoff{enforce_locktime_median_time_past ?
4223 for (
const auto& tx : block.
vtx) {
4233 if (block.
vtx[0]->vin[0].scriptSig.size() <
expect.size() ||
4234 !std::equal(
expect.begin(),
expect.end(), block.
vtx[0]->vin[0].scriptSig.begin())) {
4270 BlockMap::iterator miSelf{
m_blockman.m_block_index.find(hash)};
4272 if (miSelf !=
m_blockman.m_block_index.end()) {
4296 pindexPrev = &((*mi).second);
4331 if (pindexPrev->
GetAncestor(failedit->nHeight) == failedit) {
4334 while (invalid_walk != failedit) {
4337 invalid_walk = invalid_walk->
pprev;
4345 if (!min_pow_checked) {
4363 "Saw new header hash=%s height=%d", hash.
ToString(), pindex->
nHeight);
4397 blocks_left = std::max<int64_t>(0, blocks_left);
4398 const double progress{100.0 * last_accepted.nHeight / (last_accepted.nHeight + blocks_left)};
4399 LogInfo(
"Synchronizing blockheaders, height: %d (~%.2f%%)\n", last_accepted.nHeight, progress);
4416 auto now = std::chrono::steady_clock::now();
4417 if (now < m_last_presync_update + std::chrono::milliseconds{250})
return;
4418 m_last_presync_update = now;
4422 if (initial_download) {
4424 blocks_left = std::max<int64_t>(0, blocks_left);
4425 const double progress{100.0 * height / (height + blocks_left)};
4426 LogInfo(
"Pre-synchronizing blockheaders, height: %d (~%.2f%%)\n", height, progress);
4433 const CBlock& block = *pblock;
4435 if (fNewBlock) *fNewBlock =
false;
4439 CBlockIndex *&pindex = ppindex ? *ppindex : pindexDummy;
4441 bool accepted_header{
AcceptBlockHeader(block, state, &pindex, min_pow_checked)};
4444 if (!accepted_header)
4468 if (fAlreadyHave)
return true;
4470 if (pindex->
nTx != 0)
return true;
4471 if (!fHasMoreOrSameWork)
return true;
4472 if (fTooFarAhead)
return true;
4483 if (!
CheckBlock(block, state, params.GetConsensus()) ||
4500 if (fNewBlock) *fNewBlock =
true;
4508 if (blockPos.IsNull()) {
4509 state.
Error(
strprintf(
"%s: Failed to find position to write new block to disk", __func__));
4514 }
catch (
const std::runtime_error& e) {
4538 if (new_block) *new_block =
false;
4553 ret =
AcceptBlock(block, state, &pindex, force_processing,
nullptr, new_block, min_pow_checked);
4568 LogError(
"%s: ActivateBestChain failed (%s)\n", __func__, state.
ToString());
4574 if (bg_chain && !bg_chain->ActivateBestChain(bg_state, block)) {
4575 LogError(
"%s: [background] ActivateBestChain failed (%s)\n", __func__, bg_state.
ToString());
4602 bool fCheckMerkleRoot)
4609 indexDummy.
pprev = pindexPrev;
4615 LogError(
"%s: Consensus::ContextualCheckBlockHeader: %s\n", __func__, state.
ToString());
4623 LogError(
"%s: Consensus::ContextualCheckBlock: %s\n", __func__, state.
ToString());
4626 if (!chainstate.
ConnectBlock(block, state, &indexDummy, viewNew,
true)) {
4638 if (!active_chainstate.FlushStateToDisk(
4664 LogPrintf(
"Loaded best chain: hashBestChain=%s height=%d date=%s progress=%f\n",
4687 int nCheckLevel,
int nCheckDepth)
4696 if (nCheckDepth <= 0 || nCheckDepth > chainstate.
m_chain.
Height()) {
4699 nCheckLevel = std::max(0, std::min(4, nCheckLevel));
4700 LogPrintf(
"Verifying last %i blocks at level %i\n", nCheckDepth, nCheckLevel);
4704 int nGoodTransactions = 0;
4707 bool skipped_no_block_data{
false};
4708 bool skipped_l3_checks{
false};
4709 LogPrintf(
"Verification progress: 0%%\n");
4714 const int percentageDone = std::max(1, std::min(99, (
int)(((
double)(chainstate.
m_chain.
Height() - pindex->
nHeight)) / (
double)nCheckDepth * (nCheckLevel >= 4 ? 50 : 100))));
4715 if (reportDone < percentageDone / 10) {
4717 LogPrintf(
"Verification progress: %d%%\n", percentageDone);
4718 reportDone = percentageDone / 10;
4727 LogPrintf(
"VerifyDB(): block verification stopping at height %d (no data). This could be due to pruning or use of an assumeutxo snapshot.\n", pindex->
nHeight);
4728 skipped_no_block_data =
true;
4738 if (nCheckLevel >= 1 && !
CheckBlock(block, state, consensus_params)) {
4739 LogPrintf(
"Verification error: found bad block at %d, hash=%s (%s)\n",
4744 if (nCheckLevel >= 2 && pindex) {
4756 if (nCheckLevel >= 3) {
4765 nGoodTransactions = 0;
4766 pindexFailure = pindex;
4768 nGoodTransactions += block.
vtx.size();
4771 skipped_l3_checks =
true;
4776 if (pindexFailure) {
4777 LogPrintf(
"Verification error: coin database inconsistencies found (last %i blocks, %i good transactions before that)\n", chainstate.
m_chain.
Height() - pindexFailure->
nHeight + 1, nGoodTransactions);
4780 if (skipped_l3_checks) {
4781 LogPrintf(
"Skipped verification of level >=3 (insufficient database cache size). Consider increasing -dbcache.\n");
4788 if (nCheckLevel >= 4 && !skipped_l3_checks) {
4790 const int percentageDone = std::max(1, std::min(99, 100 - (
int)(((
double)(chainstate.
m_chain.
Height() - pindex->
nHeight)) / (
double)nCheckDepth * 50)));
4791 if (reportDone < percentageDone / 10) {
4793 LogPrintf(
"Verification progress: %d%%\n", percentageDone);
4794 reportDone = percentageDone / 10;
4803 if (!chainstate.
ConnectBlock(block, state, pindex, coins)) {
4811 LogPrintf(
"Verification: No coin database inconsistencies in last %i blocks (%i transactions)\n", block_count, nGoodTransactions);
4813 if (skipped_l3_checks) {
4816 if (skipped_no_block_data) {
4834 if (!tx->IsCoinBase()) {
4835 for (
const CTxIn &txin : tx->vin) {
4853 if (hashHeads.empty())
return true;
4854 if (hashHeads.size() != 2) {
4855 LogError(
"ReplayBlocks(): unknown inconsistent state\n");
4866 if (
m_blockman.m_block_index.count(hashHeads[0]) == 0) {
4867 LogError(
"ReplayBlocks(): reorganization to unknown block requested\n");
4870 pindexNew = &(
m_blockman.m_block_index[hashHeads[0]]);
4872 if (!hashHeads[1].IsNull()) {
4873 if (
m_blockman.m_block_index.count(hashHeads[1]) == 0) {
4874 LogError(
"ReplayBlocks(): reorganization from unknown block requested\n");
4877 pindexOld = &(
m_blockman.m_block_index[hashHeads[1]]);
4879 assert(pindexFork !=
nullptr);
4883 while (pindexOld != pindexFork) {
4901 pindexOld = pindexOld->
pprev;
4905 int nForkHeight = pindexFork ? pindexFork->
nHeight : 0;
4932 block = block->pprev;
4938 void Chainstate::ClearBlockIndexCandidates()
4950 if (!
ret)
return false;
4952 m_blockman.ScanAndUnlinkAlreadyPrunedFiles();
4954 std::vector<CBlockIndex*> vSortedByHeight{
m_blockman.GetAllBlockIndices()};
4955 std::sort(vSortedByHeight.begin(), vSortedByHeight.end(),
4965 if (pindex == GetSnapshotBaseBlock() ||
4970 chainstate->TryAddBlockIndexCandidate(pindex);
4974 m_best_invalid = pindex;
4977 m_best_header = pindex;
4993 if (
m_blockman.m_block_index.count(params.GenesisBlock().GetHash()))
4997 const CBlock& block = params.GenesisBlock();
4999 if (blockPos.IsNull()) {
5000 LogError(
"%s: writing genesis block to disk failed\n", __func__);
5005 }
catch (
const std::runtime_error& e) {
5006 LogError(
"%s: failed to write genesis block: %s\n", __func__, e.what());
5016 std::multimap<uint256, FlatFilePos>* blocks_with_unknown_parent)
5019 assert(!dbp == !blocks_with_unknown_parent);
5021 const auto start{SteadyClock::now()};
5029 uint64_t nRewind = blkdat.GetPos();
5030 while (!blkdat.eof()) {
5033 blkdat.SetPos(nRewind);
5036 unsigned int nSize = 0;
5040 blkdat.FindByte(std::byte(params.MessageStart()[0]));
5041 nRewind = blkdat.GetPos() + 1;
5043 if (buf != params.MessageStart()) {
5050 }
catch (
const std::exception&) {
5057 const uint64_t nBlockPos{blkdat.GetPos()};
5059 dbp->
nPos = nBlockPos;
5060 blkdat.SetLimit(nBlockPos + nSize);
5066 nRewind = nBlockPos + nSize;
5067 blkdat.SkipTo(nRewind);
5069 std::shared_ptr<CBlock> pblock{};
5077 if (dbp && blocks_with_unknown_parent) {
5078 blocks_with_unknown_parent->emplace(header.
hashPrevBlock, *dbp);
5087 blkdat.SetPos(nBlockPos);
5088 pblock = std::make_shared<CBlock>();
5090 nRewind = blkdat.GetPos();
5093 if (
AcceptBlock(pblock, state,
nullptr,
true, dbp,
nullptr,
true)) {
5099 }
else if (hash != params.GetConsensus().hashGenesisBlock && pindex->
nHeight % 1000 == 0) {
5105 if (hash == params.GetConsensus().hashGenesisBlock) {
5106 bool genesis_activation_failure =
false;
5107 for (
auto c :
GetAll()) {
5109 if (!c->ActivateBestChain(state,
nullptr)) {
5110 genesis_activation_failure =
true;
5114 if (genesis_activation_failure) {
5127 bool activation_failure =
false;
5128 for (
auto c :
GetAll()) {
5130 if (!c->ActivateBestChain(state, pblock)) {
5132 activation_failure =
true;
5136 if (activation_failure) {
5143 if (!blocks_with_unknown_parent)
continue;
5146 std::deque<uint256> queue;
5147 queue.push_back(hash);
5148 while (!queue.empty()) {
5151 auto range = blocks_with_unknown_parent->equal_range(head);
5152 while (range.first != range.second) {
5153 std::multimap<uint256, FlatFilePos>::iterator it = range.first;
5154 std::shared_ptr<CBlock> pblockrecursive = std::make_shared<CBlock>();
5156 LogPrint(
BCLog::REINDEX,
"%s: Processing out of order child %s of %s\n", __func__, pblockrecursive->GetHash().ToString(),
5160 if (
AcceptBlock(pblockrecursive, dummy,
nullptr,
true, &it->second,
nullptr,
true)) {
5162 queue.push_back(pblockrecursive->GetHash());
5166 blocks_with_unknown_parent->erase(it);
5170 }
catch (
const std::exception& e) {
5182 LogPrint(
BCLog::REINDEX,
"%s: unexpected data at file offset 0x%x - %s. continuing\n", __func__, (nRewind - 1), e.what());
5185 }
catch (
const std::runtime_error& e) {
5188 LogPrintf(
"Loaded %i blocks from external file in %dms\n", nLoaded, Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
5222 best_hdr_chain.
SetTip(*m_best_header);
5224 std::multimap<CBlockIndex*,CBlockIndex*> forward;
5225 for (
auto& [
_, block_index] :
m_blockman.m_block_index) {
5227 if (!best_hdr_chain.
Contains(&block_index)) {
5229 assert(block_index.pprev);
5230 forward.emplace(block_index.pprev, &block_index);
5246 CBlockIndex* pindexFirstNotTransactionsValid =
nullptr;
5248 CBlockIndex* pindexFirstNotScriptsValid =
nullptr;
5254 const CBlockIndex* snap_base{GetSnapshotBaseBlock()};
5255 CBlockIndex *snap_first_missing{}, *snap_first_notx{}, *snap_first_notv{}, *snap_first_nocv{}, *snap_first_nosv{};
5256 auto snap_update_firsts = [&] {
5257 if (pindex == snap_base) {
5258 std::swap(snap_first_missing, pindexFirstMissing);
5259 std::swap(snap_first_notx, pindexFirstNeverProcessed);
5260 std::swap(snap_first_notv, pindexFirstNotTransactionsValid);
5261 std::swap(snap_first_nocv, pindexFirstNotChainValid);
5262 std::swap(snap_first_nosv, pindexFirstNotScriptsValid);
5266 while (pindex !=
nullptr) {
5268 if (pindexFirstInvalid ==
nullptr && pindex->nStatus &
BLOCK_FAILED_VALID) pindexFirstInvalid = pindex;
5269 if (pindexFirstMissing ==
nullptr && !(pindex->nStatus &
BLOCK_HAVE_DATA)) {
5270 pindexFirstMissing = pindex;
5272 if (pindexFirstNeverProcessed ==
nullptr && pindex->
nTx == 0) pindexFirstNeverProcessed = pindex;
5275 if (pindex->
pprev !=
nullptr) {
5276 if (pindexFirstNotTransactionsValid ==
nullptr &&
5278 pindexFirstNotTransactionsValid = pindex;
5281 if (pindexFirstNotChainValid ==
nullptr &&
5283 pindexFirstNotChainValid = pindex;
5286 if (pindexFirstNotScriptsValid ==
nullptr &&
5288 pindexFirstNotScriptsValid = pindex;
5293 if (pindex->
pprev ==
nullptr) {
5296 for (
auto c :
GetAll()) {
5297 if (c->m_chain.Genesis() !=
nullptr) {
5298 assert(pindex == c->m_chain.Genesis());
5308 assert(pindexFirstMissing == pindexFirstNeverProcessed);
5314 if (snap_base && snap_base->GetAncestor(pindex->
nHeight) == pindex) {
5324 assert((pindexFirstNotTransactionsValid ==
nullptr || pindex == snap_base) == pindex->
HaveNumChainTxs());
5328 assert(pindexFirstNotTreeValid ==
nullptr);
5332 if (pindexFirstInvalid ==
nullptr) {
5337 if (!pindex->
pprev) {
5350 for (
auto c :
GetAll()) {
5351 if (c->m_chain.Tip() ==
nullptr)
continue;
5365 if (!
CBlockIndexWorkComparator()(pindex, c->m_chain.Tip()) && (pindexFirstNeverProcessed ==
nullptr || pindex == snap_base)) {
5369 if (pindexFirstInvalid ==
nullptr) {
5388 if (pindexFirstMissing ==
nullptr || pindex == c->m_chain.Tip() || pindex == c->SnapshotBase()) {
5395 assert(c->setBlockIndexCandidates.count(pindex));
5403 assert(c->setBlockIndexCandidates.count(pindex) == 0);
5407 std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> rangeUnlinked =
m_blockman.
m_blocks_unlinked.equal_range(pindex->
pprev);
5408 bool foundInUnlinked =
false;
5409 while (rangeUnlinked.first != rangeUnlinked.second) {
5410 assert(rangeUnlinked.first->first == pindex->
pprev);
5411 if (rangeUnlinked.first->second == pindex) {
5412 foundInUnlinked =
true;
5415 rangeUnlinked.first++;
5417 if (pindex->
pprev && (pindex->nStatus &
BLOCK_HAVE_DATA) && pindexFirstNeverProcessed !=
nullptr && pindexFirstInvalid ==
nullptr) {
5422 if (pindexFirstMissing ==
nullptr)
assert(!foundInUnlinked);
5423 if (pindex->
pprev && (pindex->nStatus &
BLOCK_HAVE_DATA) && pindexFirstNeverProcessed ==
nullptr && pindexFirstMissing !=
nullptr) {
5434 for (
auto c :
GetAll()) {
5437 if (pindexFirstInvalid ==
nullptr) {
5438 if (is_active || snap_base->GetAncestor(pindex->
nHeight) == pindex) {
5450 snap_update_firsts();
5451 std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> range = forward.equal_range(pindex);
5452 if (range.first != range.second) {
5454 pindex = range.first->second;
5457 }
else if (best_hdr_chain.
Contains(pindex)) {
5460 pindex = best_hdr_chain[
nHeight];
5468 snap_update_firsts();
5470 if (pindex == pindexFirstInvalid) pindexFirstInvalid =
nullptr;
5471 if (pindex == pindexFirstMissing) pindexFirstMissing =
nullptr;
5472 if (pindex == pindexFirstNeverProcessed) pindexFirstNeverProcessed =
nullptr;
5473 if (pindex == pindexFirstNotTreeValid) pindexFirstNotTreeValid =
nullptr;
5474 if (pindex == pindexFirstNotTransactionsValid) pindexFirstNotTransactionsValid =
nullptr;
5475 if (pindex == pindexFirstNotChainValid) pindexFirstNotChainValid =
nullptr;
5476 if (pindex == pindexFirstNotScriptsValid) pindexFirstNotScriptsValid =
nullptr;
5480 std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> rangePar = forward.equal_range(pindexPar);
5481 while (rangePar.first->second != pindex) {
5482 assert(rangePar.first != rangePar.second);
5487 if (rangePar.first != rangePar.second) {
5489 pindex = rangePar.first->second;
5491 }
else if (pindexPar == best_hdr_chain[
nHeight - 1]) {
5493 pindex = best_hdr_chain[
nHeight];
5495 assert((pindex ==
nullptr) == (pindexPar == best_hdr_chain.
Tip()));
5507 assert(nNodes == forward.size() + best_hdr_chain.
Height() + 1);
5514 return strprintf(
"Chainstate [%s] @ height %d (%s)",
5519 bool Chainstate::ResizeCoinsCaches(
size_t coinstip_size,
size_t coinsdb_size)
5532 LogPrintf(
"[%s] resized coinsdb cache to %.1f MiB\n",
5533 this->
ToString(), coinsdb_size * (1.0 / 1024 / 1024));
5534 LogPrintf(
"[%s] resized coinstip cache to %.1f MiB\n",
5535 this->
ToString(), coinstip_size * (1.0 / 1024 / 1024));
5540 if (coinstip_size > old_coinstip_size) {
5553 if (pindex ==
nullptr)
5557 LogWarning(
"Internal bug detected: block %d has unset nChainTx (%s %s). Please report this issue here: %s\n",
5562 int64_t nNow = time(
nullptr);
5572 return std::min<double>(pindex->
nChainTx / fTxTotal, 1.0);
5578 if (m_active_chainstate && m_active_chainstate->m_from_snapshot_blockhash) {
5580 return m_active_chainstate->m_from_snapshot_blockhash;
5582 return std::nullopt;
5588 std::vector<Chainstate*>
out;
5590 for (
Chainstate*
cs : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) {
5600 assert(!m_ibd_chainstate);
5601 assert(!m_active_chainstate);
5603 m_ibd_chainstate = std::make_unique<Chainstate>(mempool,
m_blockman, *
this);
5604 m_active_chainstate = m_ibd_chainstate.get();
5605 return *m_active_chainstate;
5617 bool existed = fs::remove(base_blockhash_path);
5619 LogPrintf(
"[snapshot] snapshot chainstate dir being removed lacks %s file\n",
5622 }
catch (
const fs::filesystem_error& e) {
5623 LogPrintf(
"[snapshot] failed to remove file %s: %s\n",
5629 LogPrintf(
"Removing leveldb dir at %s\n", path_str);
5633 const bool destroyed =
DestroyDB(path_str);
5636 LogPrintf(
"error: leveldb DestroyDB call failed on %s\n", path_str);
5663 if (!
GetParams().AssumeutxoForBlockhash(base_blockhash).has_value()) {
5665 std::string heights_formatted =
util::Join(available_heights,
", ", [&](
const auto& i) {
return util::ToString(i); });
5666 return util::Error{
strprintf(
Untranslated(
"assumeutxo block hash in snapshot metadata not recognized (hash: %s, height: %s). The following snapshot heights are available: %s"),
5669 heights_formatted)};
5673 if (!snapshot_start_block) {
5674 return util::Error{
strprintf(
Untranslated(
"The base block header (%s) must appear in the headers chain. Make sure all headers are syncing, and call loadtxoutset again"),
5679 if (start_block_invalid) {
5683 if (!m_best_header || m_best_header->GetAncestor(base_blockheight) != snapshot_start_block) {
5684 return util::Error{
_(
"A forked headers-chain with more work than the chain with the snapshot base block header exists. Please proceed to sync without AssumeUtxo.")};
5687 auto mempool{m_active_chainstate->GetMempool()};
5688 if (mempool && mempool->
size() > 0) {
5693 int64_t current_coinsdb_cache_size{0};
5694 int64_t current_coinstip_cache_size{0};
5702 static constexpr
double IBD_CACHE_PERC = 0.01;
5703 static constexpr
double SNAPSHOT_CACHE_PERC = 0.99;
5715 current_coinsdb_cache_size = this->
ActiveChainstate().m_coinsdb_cache_size_bytes;
5716 current_coinstip_cache_size = this->
ActiveChainstate().m_coinstip_cache_size_bytes;
5721 static_cast<size_t>(current_coinstip_cache_size * IBD_CACHE_PERC),
5722 static_cast<size_t>(current_coinsdb_cache_size * IBD_CACHE_PERC));
5726 return std::make_unique<Chainstate>(
5727 nullptr,
m_blockman, *
this, base_blockhash));
5731 snapshot_chainstate->InitCoinsDB(
5732 static_cast<size_t>(current_coinsdb_cache_size * SNAPSHOT_CACHE_PERC),
5733 in_memory,
false,
"chainstate");
5734 snapshot_chainstate->InitCoinsCache(
5735 static_cast<size_t>(current_coinstip_cache_size * SNAPSHOT_CACHE_PERC));
5739 this->MaybeRebalanceCaches();
5747 snapshot_chainstate.reset();
5751 "Manually remove it before restarting.\n"),
fs::PathToString(*snapshot_datadir)));
5759 return cleanup_bad_snapshot(
Untranslated(
"population failed"));
5768 return cleanup_bad_snapshot(
Untranslated(
"work does not exceed active chainstate"));
5774 return cleanup_bad_snapshot(
Untranslated(
"could not write base blockhash"));
5778 assert(!m_snapshot_chainstate);
5779 m_snapshot_chainstate.swap(snapshot_chainstate);
5780 const bool chaintip_loaded = m_snapshot_chainstate->LoadChainTip();
5785 Assert(m_active_chainstate->m_mempool->size() == 0);
5786 Assert(!m_snapshot_chainstate->m_mempool);
5787 m_snapshot_chainstate->m_mempool = m_active_chainstate->m_mempool;
5788 m_active_chainstate->m_mempool =
nullptr;
5789 m_active_chainstate = m_snapshot_chainstate.get();
5792 LogPrintf(
"[snapshot] successfully activated snapshot %s\n", base_blockhash.
ToString());
5794 m_snapshot_chainstate->CoinsTip().DynamicMemoryUsage() / (1000 * 1000));
5796 this->MaybeRebalanceCaches();
5804 snapshot_loaded ?
"saving snapshot chainstate" :
"flushing coins cache",
5808 coins_cache.
Flush();
5813 const char*
what() const noexcept
override
5815 return "ComputeUTXOStats interrupted.";
5837 if (!snapshot_start_block) {
5840 LogPrintf(
"[snapshot] Did not find snapshot start blockheader %s\n",
5845 int base_height = snapshot_start_block->
nHeight;
5848 if (!maybe_au_data) {
5849 LogPrintf(
"[snapshot] assumeutxo height in snapshot metadata not recognized "
5850 "(%d) - refusing to load snapshot\n", base_height);
5860 LogPrintf(
"[snapshot] activation failed - work does not exceed active chainstate\n");
5867 LogPrintf(
"[snapshot] loading %d coins from snapshot %s\n", coins_left, base_blockhash.
ToString());
5868 int64_t coins_processed{0};
5870 while (coins_left > 0) {
5874 size_t coins_per_txid{0};
5877 if (coins_per_txid > coins_left) {
5878 LogPrintf(
"[snapshot] mismatch in coins count in snapshot metadata and actual snapshot data\n");
5882 for (
size_t i = 0; i < coins_per_txid; i++) {
5886 outpoint.
hash = txid;
5888 if (coin.
nHeight > base_height ||
5889 outpoint.
n >= std::numeric_limits<decltype(outpoint.
n)>::max()
5891 LogPrintf(
"[snapshot] bad snapshot data after deserializing %d coins\n",
5892 coins_count - coins_left);
5896 LogPrintf(
"[snapshot] bad snapshot data after deserializing %d coins - bad tx out value\n",
5897 coins_count - coins_left);
5905 if (coins_processed % 1000000 == 0) {
5906 LogPrintf(
"[snapshot] %d coins loaded (%.2f%%, %.2f MB)\n",
5908 static_cast<float>(coins_processed) * 100 /
static_cast<float>(coins_count),
5916 if (coins_processed % 120000 == 0) {
5922 return snapshot_chainstate.GetCoinsCacheSizeState());
5935 }
catch (
const std::ios_base::failure&) {
5936 LogPrintf(
"[snapshot] bad snapshot format or truncated snapshot after deserializing %d coins\n",
5949 bool out_of_coins{
false};
5951 std::byte left_over_byte;
5952 coins_file >> left_over_byte;
5953 }
catch (
const std::ios_base::failure&) {
5955 out_of_coins =
true;
5957 if (!out_of_coins) {
5958 LogPrintf(
"[snapshot] bad snapshot - coins left over after deserializing %d coins\n",
5963 LogPrintf(
"[snapshot] loaded %d (%.2f MB) coins from snapshot %s\n",
5977 std::optional<CCoinsStats> maybe_stats;
5985 if (!maybe_stats.has_value()) {
5986 LogPrintf(
"[snapshot] failed to generate coins stats\n");
5992 LogPrintf(
"[snapshot] bad snapshot content hash: expected %s, got %s\n",
6008 constexpr
int AFTER_GENESIS_START{1};
6010 for (
int i = AFTER_GENESIS_START; i <= snapshot_chainstate.
m_chain.
Height(); ++i) {
6011 index = snapshot_chainstate.
m_chain[i];
6028 assert(index == snapshot_start_block);
6032 LogPrintf(
"[snapshot] validated snapshot (%.2f MB)\n",
6054 if (m_ibd_chainstate.get() == &this->ActiveChainstate() ||
6055 !this->IsUsable(m_snapshot_chainstate.get()) ||
6056 !this->IsUsable(m_ibd_chainstate.get()) ||
6057 !m_ibd_chainstate->m_chain.Tip()) {
6063 const int snapshot_base_height = *
Assert(this->GetSnapshotBaseHeight());
6066 if (index_new.
nHeight < snapshot_base_height) {
6076 "%s failed to validate the -assumeutxo snapshot state. "
6077 "This indicates a hardware problem, or a bug in the software, or a "
6078 "bad software modification that allowed an invalid snapshot to be "
6079 "loaded. As a result of this, the node will shut down and stop using any "
6080 "state that was built on the snapshot, resetting the chain height "
6081 "from %d to %d. On the next "
6082 "restart, the node will resume syncing from %d "
6083 "without using any snapshot data. "
6084 "Please report this incident to %s, including how you obtained the snapshot. "
6085 "The invalid snapshot chainstate will be left on disk in case it is "
6086 "helpful in diagnosing the issue that caused this error."),
6091 LogError(
"[snapshot] deleting snapshot, reverting to validated chain, and stopping node\n");
6093 m_active_chainstate = m_ibd_chainstate.get();
6094 m_snapshot_chainstate->m_disabled =
true;
6098 auto rename_result = m_snapshot_chainstate->InvalidateCoinsDBOnDisk();
6099 if (!rename_result) {
6107 LogPrintf(
"[snapshot] supposed base block %s does not match the "
6108 "snapshot base block %s (height %d). Snapshot is not valid.\n",
6109 index_new.
ToString(), snapshot_blockhash.
ToString(), snapshot_base_height);
6110 handle_invalid_snapshot();
6116 int curr_height = m_ibd_chainstate->m_chain.Height();
6118 assert(snapshot_base_height == curr_height);
6123 CCoinsViewDB& ibd_coins_db = m_ibd_chainstate->CoinsDB();
6124 m_ibd_chainstate->ForceFlushStateToDisk();
6127 if (!maybe_au_data) {
6128 LogPrintf(
"[snapshot] assumeutxo data not found for height "
6129 "(%d) - refusing to validate snapshot\n", curr_height);
6130 handle_invalid_snapshot();
6135 std::optional<CCoinsStats> maybe_ibd_stats;
6136 LogPrintf(
"[snapshot] computing UTXO stats for background chainstate to validate "
6137 "snapshot - this could take a few minutes\n");
6140 CoinStatsHashType::HASH_SERIALIZED,
6149 if (!maybe_ibd_stats) {
6150 LogPrintf(
"[snapshot] failed to generate stats for validation coins db\n");
6154 handle_invalid_snapshot();
6157 const auto& ibd_stats = *maybe_ibd_stats;
6166 LogPrintf(
"[snapshot] hash mismatch: actual=%s, expected=%s\n",
6167 ibd_stats.hashSerialized.ToString(),
6169 handle_invalid_snapshot();
6173 LogPrintf(
"[snapshot] snapshot beginning at %s has been fully validated\n",
6176 m_ibd_chainstate->m_disabled =
true;
6177 this->MaybeRebalanceCaches();
6185 assert(m_active_chainstate);
6186 return *m_active_chainstate;
6192 return m_snapshot_chainstate && m_active_chainstate == m_snapshot_chainstate.get();
6195 void ChainstateManager::MaybeRebalanceCaches()
6198 bool ibd_usable = this->
IsUsable(m_ibd_chainstate.get());
6199 bool snapshot_usable = this->
IsUsable(m_snapshot_chainstate.get());
6200 assert(ibd_usable || snapshot_usable);
6202 if (ibd_usable && !snapshot_usable) {
6207 else if (snapshot_usable && !ibd_usable) {
6209 LogPrintf(
"[snapshot] allocating all cache to the snapshot chainstate\n");
6213 else if (ibd_usable && snapshot_usable) {
6218 m_ibd_chainstate->ResizeCoinsCaches(
6220 m_snapshot_chainstate->ResizeCoinsCaches(
6223 m_snapshot_chainstate->ResizeCoinsCaches(
6225 m_ibd_chainstate->ResizeCoinsCaches(
6231 void ChainstateManager::ResetChainstates()
6233 m_ibd_chainstate.reset();
6234 m_snapshot_chainstate.reset();
6235 m_active_chainstate =
nullptr;
6245 if (!opts.check_block_index.has_value()) opts.
check_block_index = opts.chainparams.DefaultConsistencyChecks();
6246 if (!opts.minimum_chain_work.has_value()) opts.minimum_chain_work =
UintToArith256(opts.chainparams.GetConsensus().nMinimumChainWork);
6247 if (!opts.assumed_valid_block.has_value()) opts.assumed_valid_block = opts.chainparams.GetConsensus().defaultAssumeValid;
6248 return std::move(opts);
6252 : m_script_check_queue{128, options.worker_threads_num},
6253 m_interrupt{interrupt},
6255 m_blockman{interrupt,
std::move(blockman_options)},
6256 m_validation_cache{m_options.script_execution_cache_bytes, m_options.signature_cache_bytes}
6267 bool ChainstateManager::DetectSnapshotChainstate()
6269 assert(!m_snapshot_chainstate);
6275 if (!base_blockhash) {
6278 LogPrintf(
"[snapshot] detected active snapshot chainstate (%s) - loading\n",
6281 this->ActivateExistingSnapshot(*base_blockhash);
6287 assert(!m_snapshot_chainstate);
6288 m_snapshot_chainstate =
6289 std::make_unique<Chainstate>(
nullptr,
m_blockman, *
this, base_blockhash);
6290 LogPrintf(
"[snapshot] switching active chainstate to %s\n", m_snapshot_chainstate->ToString());
6293 Assert(m_active_chainstate->m_mempool->size() == 0);
6294 Assert(!m_snapshot_chainstate->m_mempool);
6295 m_snapshot_chainstate->m_mempool = m_active_chainstate->m_mempool;
6296 m_active_chainstate->m_mempool =
nullptr;
6297 m_active_chainstate = m_snapshot_chainstate.get();
6298 return *m_snapshot_chainstate;
6303 return (block_index.
nHeight==91842 && block_index.
GetBlockHash() ==
uint256S(
"0x00000000000a4d0a398161ffc163c503763b1f4360639393e0e4c8e300e0caec")) ||
6304 (block_index.
nHeight==91880 && block_index.
GetBlockHash() ==
uint256S(
"0x00000000000743f190a18c5577a3c2d2a1f610ae9601ac046a38084ccb7cd721"));
6309 return (block_index.
nHeight==91722 && block_index.
GetBlockHash() ==
uint256S(
"0x00000000000271a2dc26e7667f8419f2e15416dc6955e5a6c6cdf3f2574dd08e")) ||
6310 (block_index.
nHeight==91812 && block_index.
GetBlockHash() ==
uint256S(
"0x00000000000af0aed4792b1acee3d966af36cf5def14935db8de83d6f9306f2f"));
6317 assert(
cs.m_from_snapshot_blockhash);
6318 auto storage_path_maybe =
cs.CoinsDB().StoragePath();
6320 assert(storage_path_maybe);
6321 return *storage_path_maybe;
6331 auto invalid_path = snapshot_datadir +
"_INVALID";
6334 LogPrintf(
"[snapshot] renaming snapshot datadir %s to %s\n", dbpath, target);
6340 fs::rename(snapshot_datadir, invalid_path);
6341 }
catch (
const fs::filesystem_error& e) {
6345 LogPrintf(
"%s: error renaming file '%s' -> '%s': %s\n",
6346 __func__, src_str, dest_str, e.what());
6348 "Rename of '%s' -> '%s' failed. "
6349 "You should resolve this by manually moving or deleting the invalid "
6350 "snapshot directory %s, otherwise you will encounter the same error again "
6351 "on the next startup."),
6352 src_str, dest_str, src_str)};
6357 bool ChainstateManager::DeleteSnapshotChainstate()
6360 Assert(m_snapshot_chainstate);
6361 Assert(m_ibd_chainstate);
6365 LogPrintf(
"Deletion of %s failed. Please remove it manually to continue reindexing.\n",
6369 m_active_chainstate = m_ibd_chainstate.get();
6370 m_active_chainstate->m_mempool = m_snapshot_chainstate->m_mempool;
6371 m_snapshot_chainstate.reset();
6385 const CBlockIndex* ChainstateManager::GetSnapshotBaseBlock()
const
6387 return m_active_chainstate ? m_active_chainstate->SnapshotBase() :
nullptr;
6390 std::optional<int> ChainstateManager::GetSnapshotBaseHeight()
const
6392 const CBlockIndex* base = this->GetSnapshotBaseBlock();
6393 return base ? std::make_optional(base->
nHeight) :
std::nullopt;
6396 bool ChainstateManager::ValidatedSnapshotCleanup()
6400 if (!(chainstate && chainstate->HasCoinsViews())) {
6403 return chainstate->CoinsDB().StoragePath();
6405 std::optional<fs::path> ibd_chainstate_path_maybe = get_storage_path(m_ibd_chainstate);
6406 std::optional<fs::path> snapshot_chainstate_path_maybe = get_storage_path(m_snapshot_chainstate);
6415 if (!ibd_chainstate_path_maybe || !snapshot_chainstate_path_maybe) {
6416 LogPrintf(
"[snapshot] snapshot chainstate cleanup cannot happen with "
6417 "in-memory chainstates. You are testing, right?\n");
6421 const auto& snapshot_chainstate_path = *snapshot_chainstate_path_maybe;
6422 const auto& ibd_chainstate_path = *ibd_chainstate_path_maybe;
6430 this->ResetChainstates();
6435 LogPrintf(
"[snapshot] deleting background chainstate directory (now unnecessary) (%s)\n",
6438 fs::path tmp_old{ibd_chainstate_path +
"_todelete"};
6440 auto rename_failed_abort = [
this](
6443 const fs::filesystem_error& err) {
6444 LogError(
"[snapshot] Error renaming path (%s) -> (%s): %s\n",
6447 "Rename of '%s' -> '%s' failed. "
6448 "Cannot clean up the background chainstate leveldb directory."),
6453 fs::rename(ibd_chainstate_path, tmp_old);
6454 }
catch (
const fs::filesystem_error& e) {
6455 rename_failed_abort(ibd_chainstate_path, tmp_old, e);
6459 LogPrintf(
"[snapshot] moving snapshot chainstate (%s) to "
6460 "default chainstate directory (%s)\n",
6464 fs::rename(snapshot_chainstate_path, ibd_chainstate_path);
6465 }
catch (
const fs::filesystem_error& e) {
6466 rename_failed_abort(snapshot_chainstate_path, ibd_chainstate_path, e);
6473 LogPrintf(
"Deletion of %s failed. Please remove it manually, as the "
6474 "directory is now unnecessary.\n",
6477 LogPrintf(
"[snapshot] deleted background chainstate directory (%s)\n",
6483 Chainstate& ChainstateManager::GetChainstateForIndexing()
6488 return (this->
GetAll().size() > 1) ? *m_ibd_chainstate : *m_active_chainstate;
6491 std::pair<int, int> ChainstateManager::GetPruneRange(
const Chainstate& chainstate,
int last_height_can_prune)
6498 if (this->
GetAll().size() > 1 && m_snapshot_chainstate.get() == &chainstate) {
6501 prune_start = *
Assert(GetSnapshotBaseHeight()) + 1;
6504 int max_prune = std::max<int>(
6513 int prune_end = std::min(last_height_can_prune, max_prune);
6515 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)
#define PACKAGE_BUGREPORT
arith_uint256 GetBlockProof(const CBlockIndex &block)
const CBlockIndex * LastCommonAncestor(const CBlockIndex *pa, const CBlockIndex *pb)
Find the last common ancestor two blocks have.
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...
@ 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, checkpoint.
@ 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 Assert(val)
Identity function.
#define Assume(val)
Assume is the identity function.
Abstract class that implements BIP9-style threshold logic, and caches results.
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,...
std::string ToString() const
CBlockIndex * pprev
pointer to the index of the predecessor of 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.
bool IsValid(enum BlockStatus nUpTo=BLOCK_VALID_TRANSACTIONS) const EXCLUSIVE_LOCKS_REQUIRED(
Check whether this block index entry is valid up to the passed validity level.
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
unsigned int nChainTx
(memory only) Number of transactions in the chain up to and including this block.
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 * 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...
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.
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.
CBlockLocator GetLocator() const
Return a CBlockLocator that refers to the tip in of 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
const Consensus::Params & GetConsensus() const
RAII-style controller object for a CCheckQueue that guarantees the passed queue is finished before co...
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 bool GetCoin(const COutPoint &outpoint, Coin &coin) 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 kilovirtualbyte: CAmount / kvB.
A hasher class for Bitcoin's 256-bit hash (double SHA-256).
CHash256 & Write(Span< const unsigned char > input)
void Finalize(Span< unsigned char > output)
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...
ScriptError GetScriptError() const
SignatureCache * m_signature_cache
PrecomputedTransactionData * txdata
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 Txid & GetHash() const LIFETIMEBOUND
const Wtxid & GetWitnessHash() const LIFETIMEBOUND
const std::vector< CTxOut > vout
const std::vector< CTxIn > vin
An input of a transaction.
CTxMemPoolEntry stores data about the corresponding transaction, as well as data about all in-mempool...
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 removeRecursive(const CTransaction &tx, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs)
void UpdateTransactionsFromBlock(const std::vector< uint256 > &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 uint256 &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...
std::set< txiter, CompareIteratorByHash > setEntries
void removeForBlock(const std::vector< CTransactionRef > &vtx, unsigned int nBlockHeight) EXCLUSIVE_LOCKS_REQUIRED(cs)
Called when a block is connected.
indexed_transaction_set::nth_index< 0 >::type::const_iterator txiter
bool exists(const GenTxid >xid) const
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.
const CBlockIndex *SnapshotBase() EXCLUSIVE_LOCKS_REQUIRED(std::set< CBlockIndex *, node::CBlockIndexWorkComparator > setBlockIndexCandidates
The base of the snapshot this chainstate was created from.
CTxMemPool * GetMempool()
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.
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.
bool ConnectTip(BlockValidationState &state, CBlockIndex *pindexNew, const std::shared_ptr< const CBlock > &pblock, ConnectTrace &connectTrace, DisconnectedBlockTransactions &disconnectpool) EXCLUSIVE_LOCKS_REQUIRED(cs_main
Connect a new block to m_chain.
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(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)
CCoinsViewDB & CoinsDB() EXCLUSIVE_LOCKS_REQUIRED(
void ForceFlushStateToDisk()
Unconditionally flush all changes to disk.
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.
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...
void UpdateTip(const CBlockIndex *pindexNew) EXCLUSIVE_LOCKS_REQUIRED(SteadyClock::time_poin m_last_write)
Check warning conditions and do some notifications on new chain tip set.
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.
CCoinsViewCache & CoinsTip() EXCLUSIVE_LOCKS_REQUIRED(
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.
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.
SteadyClock::time_point m_last_flush
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.
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
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
int64_t m_total_coinstip_cache
The total number of bytes available for us to use across all in-memory coins caches.
const CChainParams & GetParams() const
const arith_uint256 & MinimumChainWork() const
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.
int64_t m_total_coinsdb_cache
The total number of bytes available for us to use across all leveldb coins databases.
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
bool IsSnapshotValidated() const EXCLUSIVE_LOCKS_REQUIRED(
Is there a snapshot in use and has it been fully validated?
RecursiveMutex & GetMutex() const LOCK_RETURNED(
Alias for cs_main.
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)
std::atomic< bool > m_cached_finished_ibd
Whether initial block download has ended and IsInitialBlockDownload should return false from now on.
std::function< void()> restart_indexes
Function to restart active indexes; set dynamically to avoid a circular dependency on base/index....
bool PopulateAndValidateSnapshot(Chainstate &snapshot_chainstate, AutoFile &coins_file, const node::SnapshotMetadata &metadata)
Internal helper for ActivateSnapshot().
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.
CBlockIndex * ActiveTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
bool IsSnapshotActive() const
ChainstateManager(const util::SignalInterrupt &interrupt, Options options, node::BlockManager::Options blockman_options)
void CheckBlockIndex()
Make various assertions about the state of the block index.
bool LoadBlockIndex() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Load the block tree and coins database from disk, initializing state if we're running with -reindex.
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(CCheckQueue< CScriptCheck > & GetCheckQueue()
When starting up, search the datadir for a chainstate based on a UTXO snapshot that is in the process...
std::optional< uint256 > SnapshotBlockhash() const
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...
const uint256 & AssumedValidBlock() const
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.
std::set< CBlockIndex * > m_failed_blocks
In order to efficiently track invalidity of headers, we keep the set of blocks which we tried to conn...
bool ProcessNewBlockHeaders(const std::vector< CBlockHeader > &block, bool min_pow_checked, BlockValidationState &state, const CBlockIndex **ppindex=nullptr) LOCKS_EXCLUDED(cs_main)
Process incoming block headers.
kernel::Notifications & GetNotifications() const
util::Result< void > ActivateSnapshot(AutoFile &coins_file, const node::SnapshotMetadata &metadata, bool in_memory)
Construct and activate a Chainstate on the basis of UTXO snapshot data.
bool IsUsable(const Chainstate *const cs) const EXCLUSIVE_LOCKS_REQUIRED(
Return true if a chainstate is considered usable.
const Consensus::Params & GetConsensus() const
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 > blocksConnected
std::vector< PerBlockConnectTrace > & GetBlocksConnected()
void BlockConnected(CBlockIndex *pindex, std::shared_ptr< const CBlock > pblock)
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.
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...
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.
static GenTxid Wtxid(const uint256 &hash)
static GenTxid Txid(const uint256 &hash)
Different type to mark Mutex at global scope.
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 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 BlockChecked(const CBlock &, const BlockValidationState &)
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
int32_t ComputeBlockVersion(const CBlockIndex *pindexPrev, const Consensus::Params ¶ms) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Determine what nVersion a new block should use.
void Clear() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Threshold condition checker that triggers when unknown versionbits are seen on the network.
int64_t EndTime(const Consensus::Params ¶ms) const override
bool Condition(const CBlockIndex *pindex, const Consensus::Params ¶ms) const override
int Threshold(const Consensus::Params ¶ms) const override
int64_t BeginTime(const Consensus::Params ¶ms) const override
int Period(const Consensus::Params ¶ms) const override
WarningBitsConditionChecker(const ChainstateManager &chainman, int bit)
const ChainstateManager & m_chainman
256-bit unsigned big integer.
constexpr bool IsNull() const
std::string ToString() const
constexpr const unsigned char * data() const
constexpr unsigned char * begin()
Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path:...
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, CBlockIndex &index)
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
bool ReadBlockFromDisk(CBlock &block, const FlatFilePos &pos) const
Functions for disk access for blocks.
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)
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
bool UndoReadFromDisk(CBlockUndo &blockundo, const CBlockIndex &index) const
void UnlinkPrunedFiles(const std::set< int > &setFilesToPrune) const
Actually unlink the specified files.
bool WriteUndoDataForBlock(const CBlockUndo &blockundo, BlockValidationState &state, CBlockIndex &block) EXCLUSIVE_LOCKS_REQUIRED(FlatFilePos SaveBlockToDisk(const CBlock &block, int nHeight)
Store block on disk and update block file statistics.
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 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)
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
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.
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_CHECKPOINT
the block failed to meet one of our checkpoints
@ 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 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, [[maybe_unused]] VersionBitsCache &versionbitscache)
Determine if a deployment is active for the next block.
bool DeploymentActiveAt(const CBlockIndex &index, const Consensus::Params ¶ms, Consensus::BuriedDeployment dep, [[maybe_unused]] 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 CheckDiskSpace(const fs::path &dir, uint64_t additional_bytes)
bool VerifyScript(const CScript &scriptSig, const CScript &scriptPubKey, const CScriptWitness *witness, unsigned int flags, const BaseSignatureChecker &checker, ScriptError *serror)
@ SCRIPT_VERIFY_NULLDUMMY
@ SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY
@ SCRIPT_VERIFY_CLEANSTACK
@ SCRIPT_VERIFY_CHECKSEQUENCEVERIFY
ChainstateRole
This enum describes the various roles a specific Chainstate instance can take.
#define LogPrintLevel(category, level,...)
#define LogPrint(category,...)
#define LogDebug(category,...)
@ REPLACED
Removed for replacement.
@ REORG
Removed for reorganization.
uint256 BlockMerkleRoot(const CBlock &block, bool *mutated)
uint256 BlockWitnessMerkleRoot(const CBlock &block, bool *mutated)
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...
static bool exists(const path &p)
static std::string PathToString(const path &path)
Convert path object to a byte string.
std::string get_filesystem_error_message(const fs::filesystem_error &e)
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)
std::optional< uint256 > ReadSnapshotBaseBlockhash(fs::path chaindir)
std::unordered_map< uint256, CBlockIndex, BlockHasher > BlockMap
bool WriteSnapshotBaseBlockhash(Chainstate &snapshot_chainstate) EXCLUSIVE_LOCKS_REQUIRED(std::optional< uint256 > constexpr ReadSnapshotBaseBlockhash(fs::path chaindir) EXCLUSIVE_LOCKS_REQUIRED(std::string_view SNAPSHOT_CHAINSTATE_SUFFIX
Write out the blockhash of the snapshot base block that was used to construct this chainstate.
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:
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 > PaysMoreThanConflicts(const CTxMemPool::setEntries &iters_conflicting, CFeeRate replacement_feerate, const uint256 &txid)
Check that the feerate of the replacement transaction(s) is higher than the feerate of each of the tr...
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::string > PaysForRBF(CAmount original_fees, CAmount replacement_fees, size_t replacement_vsize, CFeeRate relay_fee, const uint256 &txid)
The replacement transaction must pay more fees than the original transactions.
std::optional< std::string > EntriesAndTxidsDisjoint(const CTxMemPool::setEntries &ancestors, const std::set< Txid > &direct_conflicts, const uint256 &txid)
Check the intersection between two sets of transactions (a set of mempool entries and a set of txids)...
std::optional< std::pair< DiagramCheckError, std::string > > ImprovesFeerateDiagram(CTxMemPool &pool, const CTxMemPool::setEntries &direct_conflicts, const CTxMemPool::setEntries &all_conflicts, CAmount replacement_fees, int64_t replacement_vsize)
The replacement transaction must improve the feerate diagram of the mempool.
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 AreInputsStandard(const CTransaction &tx, const CCoinsViewCache &mapInputs)
Check transaction inputs to mitigate two potential denial-of-service attacks:
bool IsWitnessStandard(const CTransaction &tx, const CCoinsViewCache &mapInputs)
Check if the transaction is over standard P2WSH resources limit: 3600bytes witnessScript size,...
bool IsStandardTx(const CTransaction &tx, const std::optional< unsigned > &max_datacarrier_bytes, bool permit_bare_multisig, const CFeeRate &dust_relay_fee, std::string &reason)
Check for standard transaction types.
static constexpr unsigned int EXTRA_DESCENDANT_TX_SIZE_LIMIT
An extra transaction can be added to a package, as long as it only has one ancestor and is no larger ...
static constexpr unsigned int STANDARD_LOCKTIME_VERIFY_FLAGS
Used as the flags parameter to sequence and nLocktime checks in non-consensus code.
static constexpr unsigned int MAX_STANDARD_TX_SIGOPS_COST
The maximum number of sigops we're willing to relay/mine in a single tx.
static constexpr unsigned int MIN_STANDARD_TX_NONWITNESS_SIZE
The minimum non-witness size for transactions we're willing to relay/mine: one larger than 64
static constexpr unsigned int STANDARD_SCRIPT_VERIFY_FLAGS
Standard script verification flags that standard transactions will comply with.
static constexpr unsigned int STANDARD_NOT_MANDATORY_VERIFY_FLAGS
For convenience, standard but not mandatory verify flags.
unsigned int GetNextWorkRequired(const CBlockIndex *pindexLast, const CBlockHeader *pblock, const Consensus::Params ¶ms)
bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params ¶ms)
Check whether a block hash satisfies the proof-of-work requirement specified by nBits.
static constexpr TransactionSerParams TX_NO_WITNESS
static constexpr TransactionSerParams TX_WITH_WITNESS
static CTransactionRef MakeTransactionRef(Tx &&txIn)
std::shared_ptr< const CTransaction > CTransactionRef
uint256 GetRandHash() noexcept
Generate a random uint256.
reverse_range< T > reverse_iterate(T &x)
std::string ScriptErrorString(const ScriptError serror)
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.
unsigned int nChainTx
Used to populate the nChainTx 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.
double dTxRate
estimated number of transactions per second after that timestamp
int64_t nTime
UNIX timestamp of last known number of transactions.
int64_t nTxCount
total number of transactions between genesis and that timestamp
User-controlled performance and debug options.
Parameters that influence chain consensus.
uint32_t nMinerConfirmationWindow
std::map< uint256, uint32_t > script_flag_exceptions
Hashes of blocks that.
bool signet_blocks
If true, witness commitments contain a payload equal to a Bitcoin Script solution to the signet chall...
int nSubsidyHalvingInterval
int MinBIP9WarningHeight
Don't warn about unknown BIP 9 activations below this height.
uint32_t nRuleChangeActivationThreshold
Minimum blocks including miner confirmation of the total of 2016 blocks in a retargeting period,...
std::chrono::seconds PowTargetSpacing() const
Application-specific storage settings.
fs::path path
Location in the filesystem where leveldb data will be stored.
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.
static MempoolAcceptResult MempoolTxDifferentWitness(const uint256 &other_wtxid)
@ 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 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.
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(...)
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
#define LOG_TIME_MILLIS_WITH_CATEGORY(end_msg, log_category)
#define LOG_TIME_MILLIS_WITH_CATEGORY_MSG_ONCE(end_msg, log_category)
#define TRACE6(context, event, a, b, c, d, e, f)
#define TRACE5(context, event, a, b, c, d, e)
#define TRACE2(context, event, a, b)
#define TRACE7(context, event, a, b, c, d, e, f, g)
bilingual_str _(ConstevalStringLiteral str)
Translation function.
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.
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.
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.
static constexpr decltype(CTransaction::version) TRUC_VERSION
bool CheckTransaction(const CTransaction &tx, TxValidationState &state)
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...
bool EvaluateSequenceLocks(const CBlockIndex &block, std::pair< int, int64_t > lockPair)
int64_t GetTransactionSigOpCost(const CTransaction &tx, const CCoinsViewCache &inputs, uint32_t flags)
Compute total signature operation cost of a transaction.
unsigned int GetLegacySigOpCount(const CTransaction &tx)
Auxiliary functions for transaction validation (ideally should not be exposed)
bool SequenceLocks(const CTransaction &tx, int flags, std::vector< int > &prevHeights, const CBlockIndex &block)
Check if transaction is final per BIP 68 sequence numbers and can be included in a block.
bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64_t nBlockTime)
Check if transaction is final and can be included in a block with the specified height and time.
bool TestLockPointValidity(CChain &active_chain, const LockPoints &lp)
Test whether the LockPoints height and time are still valid on the current chain.
static const uint32_t MEMPOOL_HEIGHT
Fake height value used in Coin to signify they are only in the memory pool (since 0....
uint256 uint256S(std::string_view str)
bool SignalsOptInRBF(const CTransaction &tx)
Check whether the sequence numbers on this transaction are signaling opt-in to replace-by-fee,...
static void UpdateTipLog(const CCoinsViewCache &coins_tip, const CBlockIndex *tip, const CChainParams ¶ms, const std::string &func_name, const std::string &prefix, const std::string &warning_messages) EXCLUSIVE_LOCKS_REQUIRED(
PackageMempoolAcceptResult ProcessNewPackage(Chainstate &active_chainstate, CTxMemPool &pool, const Package &package, bool test_accept, const std::optional< CFeeRate > &client_maxfeerate)
Validate (and maybe submit) a package to the mempool.
bool CheckInputScripts(const CTransaction &tx, TxValidationState &state, const CCoinsViewCache &inputs, unsigned int flags, bool cacheSigStore, bool cacheFullScriptStore, PrecomputedTransactionData &txdata, ValidationCache &validation_cache, std::vector< CScriptCheck > *pvChecks=nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Check whether all of this transaction's input scripts succeed.
static void LimitMempoolSize(CTxMemPool &pool, CCoinsViewCache &coins_cache) EXCLUSIVE_LOCKS_REQUIRED(
bool IsBlockMutated(const CBlock &block, bool check_witness_root)
Check if a block has been mutated (with respect to its merkle root and witness commitments).
static unsigned int GetBlockScriptFlags(const CBlockIndex &block_index, const ChainstateManager &chainman)
GlobalMutex g_best_block_mutex
std::condition_variable g_best_block_cv
double GuessVerificationProgress(const ChainTxData &data, const CBlockIndex *pindex)
Guess how far we are in the verification process at the given block index require cs_main if pindex h...
bool CheckFinalTxAtTip(const CBlockIndex &active_chain_tip, const CTransaction &tx)
CAmount GetBlockSubsidy(int nHeight, const Consensus::Params &consensusParams)
MempoolAcceptResult AcceptToMemoryPool(Chainstate &active_chainstate, const CTransactionRef &tx, int64_t accept_time, bool bypass_limits, bool test_accept)
Try to add a transaction to the mempool.
int ApplyTxInUndo(Coin &&undo, CCoinsViewCache &view, const COutPoint &out)
Restore the UTXO in a Coin at a given COutPoint.
static bool ContextualCheckBlock(const CBlock &block, BlockValidationState &state, const ChainstateManager &chainman, const CBlockIndex *pindexPrev)
NOTE: This function is not currently invoked by ConnectBlock(), so we should consider upgrade issues ...
bool FatalError(Notifications ¬ifications, BlockValidationState &state, const bilingual_str &message)
bool CheckSequenceLocksAtTip(CBlockIndex *tip, const LockPoints &lock_points)
Check if transaction will be BIP68 final in the next block to be created on top of tip.
static bool CheckInputsFromMempoolAndCache(const CTransaction &tx, TxValidationState &state, const CCoinsViewCache &view, const CTxMemPool &pool, unsigned int flags, PrecomputedTransactionData &txdata, CCoinsViewCache &coins_tip, ValidationCache &validation_cache) EXCLUSIVE_LOCKS_REQUIRED(cs_main
Checks to avoid mempool polluting consensus critical paths since cached signature and script validity...
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 constexpr std::chrono::hours DATABASE_FLUSH_INTERVAL
Time to wait between flushing chainstate to disk.
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.
bool IsBIP30Unspendable(const CBlockIndex &block_index)
Identifies blocks which coinbase output was subsequently overwritten in the UTXO set (see BIP30)
const std::vector< std::string > CHECKLEVEL_DOC
Documentation for argument 'checklevel'.
static ChainstateManager::Options && Flatten(ChainstateManager::Options &&opts)
Apply default chain params to nullopt members.
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)
bool TestBlockValidity(BlockValidationState &state, const CChainParams &chainparams, Chainstate &chainstate, const CBlock &block, CBlockIndex *pindexPrev, bool fCheckPOW, bool fCheckMerkleRoot)
Check a block is completely valid from start to finish (only works on top of our current best block)
static bool IsCurrentForFeeEstimation(Chainstate &active_chainstate) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
std::optional< LockPoints > CalculateLockPointsAtTip(CBlockIndex *tip, const CCoinsView &coins_view, const CTransaction &tx)
static bool CheckBlockHeader(const CBlockHeader &block, BlockValidationState &state, const Consensus::Params &consensusParams, bool fCheckPOW=true)
arith_uint256 CalculateClaimedHeadersWork(const std::vector< CBlockHeader > &headers)
Return the sum of the claimed work on a given set of headers.
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(
uint256 g_best_block
Used to notify getblocktemplate RPC of new tips.
static SynchronizationState GetSynchronizationState(bool init, bool blockfiles_indexed)
static constexpr std::chrono::hours DATABASE_WRITE_INTERVAL
Time to wait between writing blocks/block index to disk.
static bool ContextualCheckBlockHeader(const CBlockHeader &block, BlockValidationState &state, BlockManager &blockman, const ChainstateManager &chainman, const CBlockIndex *pindexPrev) EXCLUSIVE_LOCKS_REQUIRED(
Context-dependent validity checks.
static void LimitValidationInterfaceQueue(ValidationSignals &signals) LOCKS_EXCLUDED(cs_main)
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.
@ LARGE
The cache is at >= 90% capacity.
@ CRITICAL
The coins cache is in immediate need of a flush.
static const int32_t VERSIONBITS_NUM_BITS
Total bits available for versionbits.
static const int32_t VERSIONBITS_TOP_BITS
What bits to set in version for versionbits blocks.
static const int32_t VERSIONBITS_TOP_MASK
What bitmask determines whether versionbits is in use.
ThresholdState
BIP 9 defines a finite-state-machine to deploy a softfork in multiple stages.