6 #if defined(HAVE_CONFIG_H)
98 "level 0 reads the blocks from disk",
99 "level 1 verifies block validity",
100 "level 2 verifies undo data",
101 "level 3 checks disconnection of tip blocks",
102 "level 4 tries to reconnect the blocks",
103 "each level includes the checks of the previous levels",
139 std::vector<CScriptCheck>* pvChecks =
nullptr)
152 const int nBlockHeight = active_chain_tip.nHeight + 1;
159 const int64_t nBlockTime{active_chain_tip.GetMedianTimePast()};
161 return IsFinalTx(tx, nBlockHeight, nBlockTime);
175 std::optional<std::vector<int>> CalculatePrevHeights(
180 std::vector<int> prev_heights;
181 prev_heights.resize(tx.
vin.size());
182 for (
size_t i = 0; i < tx.
vin.size(); ++i) {
191 prev_heights[i] = tip.
nHeight + 1;
193 prev_heights[i] = coin.
nHeight;
207 auto prev_heights{CalculatePrevHeights(*tip, coins_view, tx)};
208 if (!prev_heights.has_value())
return std::nullopt;
211 next_tip.
pprev = tip;
229 int max_input_height{0};
230 for (
const int height : prev_heights.value()) {
232 if (height != next_tip.
nHeight) {
233 max_input_height = std::max(max_input_height, height);
271 int expired = pool.Expire(GetTime<std::chrono::seconds>() - pool.m_expiry);
276 std::vector<COutPoint> vNoSpendsRemaining;
277 pool.TrimToSize(pool.m_max_size_bytes, &vNoSpendsRemaining);
278 for (
const COutPoint& removed : vNoSpendsRemaining)
279 coins_cache.Uncache(removed);
285 if (active_chainstate.m_chainman.IsInitialBlockDownload()) {
290 if (active_chainstate.m_chain.Height() < active_chainstate.m_chainman.m_best_header->nHeight - 1) {
304 std::vector<uint256> vHashUpdate;
311 const auto queuedTx = disconnectpool.
take();
312 auto it = queuedTx.rbegin();
313 while (it != queuedTx.rend()) {
315 if (!fAddToMempool || (*it)->IsCoinBase() ||
317 true,
false).m_result_type !=
323 vHashUpdate.push_back((*it)->GetHash());
364 it->UpdateLockPoints(*new_lock_points);
371 if (it->GetSpendsCoinbase()) {
377 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;
461 const bool m_test_accept;
465 const bool m_allow_replacement;
470 const bool m_package_submission;
474 const bool m_package_feerates;
479 const std::optional<CFeeRate> m_client_maxfeerate;
482 static ATMPArgs SingleAccept(
const CChainParams& chainparams, int64_t accept_time,
483 bool bypass_limits, std::vector<COutPoint>& coins_to_uncache,
485 return ATMPArgs{ chainparams,
498 static ATMPArgs PackageTestAccept(
const CChainParams& chainparams, int64_t accept_time,
499 std::vector<COutPoint>& coins_to_uncache) {
500 return ATMPArgs{ chainparams,
513 static ATMPArgs PackageChildWithParents(
const CChainParams& chainparams, int64_t accept_time,
514 std::vector<COutPoint>& coins_to_uncache,
const std::optional<CFeeRate>& client_maxfeerate) {
515 return ATMPArgs{ chainparams,
528 static ATMPArgs SingleInPackageAccept(
const ATMPArgs& package_args) {
529 return ATMPArgs{ package_args.m_chainparams,
530 package_args.m_accept_time,
532 package_args.m_coins_to_uncache,
533 package_args.m_test_accept,
537 package_args.m_client_maxfeerate,
547 std::vector<COutPoint>& coins_to_uncache,
549 bool allow_replacement,
550 bool package_submission,
551 bool package_feerates,
552 std::optional<CFeeRate> client_maxfeerate)
553 : m_chainparams{chainparams},
554 m_accept_time{accept_time},
555 m_bypass_limits{bypass_limits},
556 m_coins_to_uncache{coins_to_uncache},
557 m_test_accept{test_accept},
558 m_allow_replacement{allow_replacement},
559 m_package_submission{package_submission},
560 m_package_feerates{package_feerates},
561 m_client_maxfeerate{client_maxfeerate}
602 explicit Workspace(
const CTransactionRef& ptx) : m_ptx(ptx), m_hash(ptx->GetHash()) {}
605 std::set<Txid> m_conflicts;
616 std::unique_ptr<CTxMemPoolEntry> m_entry;
620 std::list<CTransactionRef> m_replaced_transactions;
623 bool m_sibling_eviction{
false};
635 size_t m_conflicting_size{0};
662 bool PackageMempoolChecks(
const std::vector<CTransactionRef>& txns,
685 std::map<uint256, MempoolAcceptResult>& results)
693 CAmount mempoolRejectFee = m_pool.GetMinFee().GetFee(package_size);
694 if (mempoolRejectFee > 0 && package_fee < mempoolRejectFee) {
698 if (package_fee < m_pool.m_min_relay_feerate.GetFee(package_size)) {
700 strprintf(
"%d < %d", package_fee, m_pool.m_min_relay_feerate.GetFee(package_size)));
718 bool MemPoolAccept::PreChecks(ATMPArgs&
args, Workspace& ws)
724 const Txid& hash = ws.m_hash;
727 const int64_t nAcceptTime =
args.m_accept_time;
728 const bool bypass_limits =
args.m_bypass_limits;
729 std::vector<COutPoint>& coins_to_uncache =
args.m_coins_to_uncache;
733 std::unique_ptr<CTxMemPoolEntry>& entry = ws.m_entry;
745 if (m_pool.m_require_standard && !
IsStandardTx(tx, m_pool.m_max_datacarrier_bytes, m_pool.m_permit_bare_multisig, m_pool.m_dust_relay_feerate, reason)) {
773 if (ptxConflicting) {
774 if (!
args.m_allow_replacement) {
778 if (!ws.m_conflicts.count(ptxConflicting->
GetHash()))
797 ws.m_conflicts.insert(ptxConflicting->
GetHash());
802 m_view.SetBackend(m_viewmempool);
808 coins_to_uncache.push_back(txin.
prevout);
814 if (!m_view.HaveCoin(txin.
prevout)) {
829 m_view.GetBestBlock();
834 m_view.SetBackend(m_dummy);
836 assert(m_active_chainstate.m_blockman.LookupBlockIndex(m_view.GetBestBlock()) == m_active_chainstate.m_chain.Tip());
843 const std::optional<LockPoints> lock_points{
CalculateLockPointsAtTip(m_active_chainstate.m_chain.Tip(), m_view, tx)};
865 ws.m_modified_fees = ws.m_base_fees;
866 m_pool.ApplyDelta(hash, ws.m_modified_fees);
870 bool fSpendsCoinbase =
false;
872 const Coin &coin = m_view.AccessCoin(txin.
prevout);
874 fSpendsCoinbase =
true;
881 const uint64_t entry_sequence = bypass_limits ? 0 : m_pool.GetSequence();
882 entry.reset(
new CTxMemPoolEntry(ptx, ws.m_base_fees, nAcceptTime, m_active_chainstate.m_chain.Height(), entry_sequence,
883 fSpendsCoinbase, nSigOpsCost, lock_points.value()));
884 ws.m_vsize = entry->GetTxSize();
896 if (!bypass_limits && ws.m_ptx->nVersion != 3 && ws.m_modified_fees < m_pool.m_min_relay_feerate.GetFee(ws.m_vsize)) {
900 strprintf(
"%d < %d", ws.m_modified_fees, m_pool.m_min_relay_feerate.GetFee(ws.m_vsize)));
905 if (!bypass_limits && !
args.m_package_feerates && !
CheckFeeRate(ws.m_vsize, ws.m_modified_fees, state))
return false;
907 ws.m_iters_conflicting = m_pool.GetIterSet(ws.m_conflicts);
914 if (ws.m_conflicts.size() == 1) {
942 assert(ws.m_iters_conflicting.size() == 1);
949 auto ancestors{m_pool.CalculateMemPoolAncestors(*entry, maybe_rbf_limits)};
973 ancestors = m_pool.CalculateMemPoolAncestors(*entry, cpfp_carve_out_limits);
977 ws.m_ancestors = *ancestors;
981 if (
const auto err{
SingleV3Checks(ws.m_ptx, ws.m_ancestors, ws.m_conflicts, ws.m_vsize)}) {
983 if (err->second !=
nullptr &&
args.m_allow_replacement) {
986 ws.m_conflicts.insert(err->second->GetHash());
990 ws.m_iters_conflicting.insert(m_pool.GetIter(err->second->GetHash()).value());
991 ws.m_sibling_eviction =
true;
1011 m_rbf = !ws.m_conflicts.empty();
1015 bool MemPoolAccept::ReplacementChecks(Workspace& ws)
1021 const uint256& hash = ws.m_hash;
1024 CFeeRate newFeeRate(ws.m_modified_fees, ws.m_vsize);
1039 strprintf(
"insufficient fee%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1043 if (
const auto err_string{
GetEntriesForConflicts(tx, m_pool, ws.m_iters_conflicting, ws.m_all_conflicting)}) {
1045 strprintf(
"too many potential replacements%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1050 Assume(!ws.m_sibling_eviction);
1052 strprintf(
"replacement-adds-unconfirmed%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1057 ws.m_conflicting_fees += it->GetModifiedFee();
1058 ws.m_conflicting_size += it->GetTxSize();
1060 if (
const auto err_string{
PaysForRBF(ws.m_conflicting_fees, ws.m_modified_fees, ws.m_vsize,
1061 m_pool.m_incremental_relay_feerate, hash)}) {
1066 strprintf(
"insufficient fee%s", ws.m_sibling_eviction ?
" (including sibling eviction)" :
""), *err_string);
1071 bool MemPoolAccept::PackageMempoolChecks(
const std::vector<CTransactionRef>& txns,
1072 const int64_t total_vsize,
1079 assert(std::all_of(txns.cbegin(), txns.cend(), [
this](
const auto& tx)
1080 { return !m_pool.exists(GenTxid::Txid(tx->GetHash()));}));
1082 auto result = m_pool.CheckPackageLimits(txns, total_vsize);
1090 bool MemPoolAccept::PolicyScriptChecks(
const ATMPArgs&
args, Workspace& ws)
1101 if (!
CheckInputScripts(tx, state, m_view, scriptVerifyFlags,
true,
false, ws.m_precomputed_txdata)) {
1118 bool MemPoolAccept::ConsensusScriptChecks(
const ATMPArgs&
args, Workspace& ws)
1123 const uint256& hash = ws.m_hash;
1141 unsigned int currentBlockScriptVerifyFlags{
GetBlockScriptFlags(*m_active_chainstate.m_chain.Tip(), m_active_chainstate.m_chainman)};
1143 ws.m_precomputed_txdata, m_active_chainstate.CoinsTip())) {
1144 LogPrintf(
"BUG! PLEASE REPORT THIS! CheckInputScripts failed against latest-block but not STANDARD flags %s, %s\n", hash.
ToString(), state.
ToString());
1151 bool MemPoolAccept::Finalize(
const ATMPArgs&
args, Workspace& ws)
1156 const uint256& hash = ws.m_hash;
1158 const bool bypass_limits =
args.m_bypass_limits;
1160 std::unique_ptr<CTxMemPoolEntry>& entry = ws.m_entry;
1165 LogPrint(
BCLog::MEMPOOL,
"replacing tx %s (wtxid=%s) with %s (wtxid=%s) for %s additional fees, %d delta bytes\n",
1166 it->GetTx().GetHash().ToString(),
1167 it->GetTx().GetWitnessHash().ToString(),
1170 FormatMoney(ws.m_modified_fees - ws.m_conflicting_fees),
1171 (
int)entry->GetTxSize() - (
int)ws.m_conflicting_size);
1172 TRACE7(mempool, replaced,
1173 it->GetTx().GetHash().data(),
1176 std::chrono::duration_cast<std::chrono::duration<std::uint64_t>>(it->GetTime()).count(),
1181 ws.m_replaced_transactions.push_back(it->GetSharedTx());
1185 m_pool.addUnchecked(*entry, ws.m_ancestors);
1191 if (!
args.m_package_submission && !bypass_limits) {
1200 bool MemPoolAccept::SubmitPackage(
const ATMPArgs&
args, std::vector<Workspace>& workspaces,
1202 std::map<uint256, MempoolAcceptResult>& results)
1208 assert(std::all_of(workspaces.cbegin(), workspaces.cend(), [
this](
const auto& ws){
1209 return !m_pool.exists(GenTxid::Txid(ws.m_ptx->GetHash())); }));
1211 bool all_submitted =
true;
1216 for (Workspace& ws : workspaces) {
1217 if (!ConsensusScriptChecks(
args, ws)) {
1221 all_submitted =
false;
1223 strprintf(
"BUG! PolicyScriptChecks succeeded but ConsensusScriptChecks failed: %s",
1224 ws.m_ptx->GetHash().ToString()));
1230 auto ancestors{m_pool.CalculateMemPoolAncestors(*ws.m_entry, m_pool.m_limits)};
1235 all_submitted =
false;
1237 strprintf(
"BUG! Mempool ancestors or descendants were underestimated: %s",
1238 ws.m_ptx->GetHash().ToString()));
1240 ws.m_ancestors = std::move(ancestors).value_or(ws.m_ancestors);
1247 if (!Finalize(
args, ws)) {
1251 all_submitted =
false;
1253 strprintf(
"BUG! Adding to mempool failed: %s", ws.m_ptx->GetHash().ToString()));
1257 std::vector<Wtxid> all_package_wtxids;
1258 all_package_wtxids.reserve(workspaces.size());
1259 std::transform(workspaces.cbegin(), workspaces.cend(), std::back_inserter(all_package_wtxids),
1260 [](
const auto& ws) { return ws.m_ptx->GetWitnessHash(); });
1263 for (Workspace& ws : workspaces) {
1264 const auto effective_feerate =
args.m_package_feerates ? ws.m_package_feerate :
1265 CFeeRate{ws.m_modified_fees,
static_cast<uint32_t
>(ws.m_vsize)};
1266 const auto effective_feerate_wtxids =
args.m_package_feerates ? all_package_wtxids :
1267 std::vector<Wtxid>{ws.m_ptx->GetWitnessHash()};
1268 results.emplace(ws.m_ptx->GetWitnessHash(),
1270 ws.m_base_fees, effective_feerate, effective_feerate_wtxids));
1271 if (!m_pool.m_signals)
continue;
1274 ws.m_vsize, ws.m_entry->GetHeight(),
1275 args.m_bypass_limits,
args.m_package_submission,
1277 m_pool.HasNoInputsOf(tx));
1278 m_pool.m_signals->TransactionAddedToMempool(tx_info, m_pool.GetAndIncrementSequence());
1280 return all_submitted;
1289 const std::vector<Wtxid> single_wtxid{ws.m_ptx->GetWitnessHash()};
1291 if (!PreChecks(
args, ws)) {
1300 if (
args.m_client_maxfeerate &&
CFeeRate(ws.m_modified_fees, ws.m_vsize) >
args.m_client_maxfeerate.value()) {
1313 const CFeeRate effective_feerate{ws.m_modified_fees,
static_cast<uint32_t
>(ws.m_vsize)};
1315 if (
args.m_test_accept) {
1317 ws.m_base_fees, effective_feerate, single_wtxid);
1320 if (!Finalize(
args, ws)) {
1327 if (m_pool.m_signals) {
1330 ws.m_vsize, ws.m_entry->GetHeight(),
1331 args.m_bypass_limits,
args.m_package_submission,
1333 m_pool.HasNoInputsOf(tx));
1334 m_pool.m_signals->TransactionAddedToMempool(tx_info, m_pool.GetAndIncrementSequence());
1338 effective_feerate, single_wtxid);
1349 std::vector<Workspace> workspaces{};
1350 workspaces.reserve(txns.size());
1351 std::transform(txns.cbegin(), txns.cend(), std::back_inserter(workspaces),
1352 [](
const auto& tx) { return Workspace(tx); });
1353 std::map<uint256, MempoolAcceptResult> results;
1358 for (Workspace& ws : workspaces) {
1359 if (!PreChecks(
args, ws)) {
1368 if (
args.m_client_maxfeerate &&
CFeeRate(ws.m_modified_fees, ws.m_vsize) >
args.m_client_maxfeerate.value()) {
1382 m_viewmempool.PackageAddTransaction(ws.m_ptx);
1387 for (Workspace& ws : workspaces) {
1388 if (
auto err{
PackageV3Checks(ws.m_ptx, ws.m_vsize, txns, ws.m_ancestors)}) {
1403 const auto m_total_vsize = std::accumulate(workspaces.cbegin(), workspaces.cend(), int64_t{0},
1404 [](int64_t
sum,
auto& ws) { return sum + ws.m_vsize; });
1405 const auto m_total_modified_fees = std::accumulate(workspaces.cbegin(), workspaces.cend(),
CAmount{0},
1406 [](
CAmount sum,
auto& ws) { return sum + ws.m_modified_fees; });
1407 const CFeeRate package_feerate(m_total_modified_fees, m_total_vsize);
1408 std::vector<Wtxid> all_package_wtxids;
1409 all_package_wtxids.reserve(workspaces.size());
1410 std::transform(workspaces.cbegin(), workspaces.cend(), std::back_inserter(all_package_wtxids),
1411 [](
const auto& ws) { return ws.m_ptx->GetWitnessHash(); });
1413 if (
args.m_package_feerates &&
1414 !
CheckFeeRate(m_total_vsize, m_total_modified_fees, placeholder_state)) {
1423 std::string err_string;
1424 if (txns.size() > 1 && !PackageMempoolChecks(txns, m_total_vsize, package_state)) {
1428 for (Workspace& ws : workspaces) {
1429 ws.m_package_feerate = package_feerate;
1430 if (!PolicyScriptChecks(
args, ws)) {
1436 if (
args.m_test_accept) {
1437 const auto effective_feerate =
args.m_package_feerates ? ws.m_package_feerate :
1438 CFeeRate{ws.m_modified_fees,
static_cast<uint32_t
>(ws.m_vsize)};
1439 const auto effective_feerate_wtxids =
args.m_package_feerates ? all_package_wtxids :
1440 std::vector<Wtxid>{ws.m_ptx->GetWitnessHash()};
1441 results.emplace(ws.m_ptx->GetWitnessHash(),
1443 ws.m_vsize, ws.m_base_fees, effective_feerate,
1444 effective_feerate_wtxids));
1450 if (!SubmitPackage(
args, workspaces, package_state, results)) {
1458 void MemPoolAccept::CleanupTemporaryCoins()
1478 for (
const auto& outpoint : m_viewmempool.GetNonBaseCoins()) {
1481 m_view.Uncache(outpoint);
1484 m_viewmempool.Reset();
1492 if (subpackage.size() > 1) {
1493 return AcceptMultipleTransactions(subpackage,
args);
1495 const auto& tx = subpackage.front();
1496 ATMPArgs single_args = ATMPArgs::SingleInPackageAccept(
args);
1497 const auto single_res = AcceptSingleTransaction(tx, single_args);
1507 CleanupTemporaryCoins();
1534 assert(package.size() > 1);
1537 const auto& child = package.back();
1538 std::unordered_set<uint256, SaltedTxidHasher> unconfirmed_parent_txids;
1539 std::transform(package.cbegin(), package.cend() - 1,
1540 std::inserter(unconfirmed_parent_txids, unconfirmed_parent_txids.end()),
1541 [](
const auto& tx) { return tx->GetHash(); });
1548 const CCoinsViewCache& coins_tip_cache = m_active_chainstate.CoinsTip();
1549 for (
const auto& input : child->vin) {
1551 args.m_coins_to_uncache.push_back(input.prevout);
1557 m_view.SetBackend(m_active_chainstate.CoinsTip());
1558 const auto package_or_confirmed = [
this, &unconfirmed_parent_txids](
const auto& input) {
1559 return unconfirmed_parent_txids.count(input.prevout.hash) > 0 || m_view.HaveCoin(input.prevout);
1561 if (!std::all_of(child->vin.cbegin(), child->vin.cend(), package_or_confirmed)) {
1567 m_view.SetBackend(m_dummy);
1572 std::map<uint256, MempoolAcceptResult> results_final;
1576 std::map<uint256, MempoolAcceptResult> individual_results_nonfinal;
1577 bool quit_early{
false};
1578 std::vector<CTransactionRef> txns_package_eval;
1579 for (
const auto& tx : package) {
1581 const auto& txid = tx->
GetHash();
1595 const auto& entry{*
Assert(m_pool.GetEntry(txid))};
1605 const auto& entry{*
Assert(m_pool.GetEntry(txid))};
1611 const auto single_package_res = AcceptSubPackage({tx},
args);
1612 const auto& single_res = single_package_res.m_tx_results.at(wtxid);
1617 results_final.emplace(wtxid, single_res);
1631 individual_results_nonfinal.emplace(wtxid, single_res);
1633 individual_results_nonfinal.emplace(wtxid, single_res);
1634 txns_package_eval.push_back(tx);
1639 auto multi_submission_result = quit_early || txns_package_eval.empty() ?
PackageMempoolAcceptResult(package_state_quit_early, {}) :
1640 AcceptSubPackage(txns_package_eval,
args);
1647 for (
const auto& tx : package) {
1649 if (multi_submission_result.m_tx_results.count(wtxid) > 0) {
1651 Assume(results_final.count(wtxid) == 0);
1654 const auto& txresult = multi_submission_result.m_tx_results.at(wtxid);
1661 results_final.emplace(wtxid, txresult);
1663 }
else if (
const auto it{results_final.find(wtxid)}; it != results_final.end()) {
1667 Assume(individual_results_nonfinal.count(wtxid) == 0);
1674 results_final.erase(wtxid);
1677 }
else if (
const auto it{individual_results_nonfinal.find(wtxid)}; it != individual_results_nonfinal.end()) {
1680 results_final.emplace(wtxid, it->second);
1683 Assume(results_final.size() == package.size());
1690 int64_t accept_time,
bool bypass_limits,
bool test_accept)
1694 const CChainParams& chainparams{active_chainstate.m_chainman.GetParams()};
1695 assert(active_chainstate.GetMempool() !=
nullptr);
1696 CTxMemPool& pool{*active_chainstate.GetMempool()};
1698 std::vector<COutPoint> coins_to_uncache;
1699 auto args = MemPoolAccept::ATMPArgs::SingleAccept(chainparams, accept_time, bypass_limits, coins_to_uncache, test_accept);
1707 for (
const COutPoint& hashTx : coins_to_uncache)
1708 active_chainstate.CoinsTip().Uncache(hashTx);
1709 TRACE2(mempool, rejected,
1721 const Package& package,
bool test_accept,
const std::optional<CFeeRate>& client_maxfeerate)
1724 assert(!package.empty());
1725 assert(std::all_of(package.cbegin(), package.cend(), [](
const auto& tx){return tx != nullptr;}));
1727 std::vector<COutPoint> coins_to_uncache;
1732 auto args = MemPoolAccept::ATMPArgs::PackageTestAccept(chainparams,
GetTime(), coins_to_uncache);
1733 return MemPoolAccept(pool, active_chainstate).AcceptMultipleTransactions(package,
args);
1735 auto args = MemPoolAccept::ATMPArgs::PackageChildWithParents(chainparams,
GetTime(), coins_to_uncache, client_maxfeerate);
1736 return MemPoolAccept(pool, active_chainstate).AcceptPackage(package,
args);
1741 if (test_accept || result.m_state.IsInvalid()) {
1742 for (
const COutPoint& hashTx : coins_to_uncache) {
1761 nSubsidy >>= halvings;
1766 : m_dbview{
std::move(db_params),
std::move(options)},
1767 m_catcherview(&m_dbview) {}
1769 void CoinsViews::InitCache()
1772 m_cacheview = std::make_unique<CCoinsViewCache>(&m_catcherview);
1779 std::optional<uint256> from_snapshot_blockhash)
1780 : m_mempool(mempool),
1781 m_blockman(blockman),
1782 m_chainman(chainman),
1783 m_from_snapshot_blockhash(from_snapshot_blockhash) {}
1789 return m_cached_snapshot_base;
1792 void Chainstate::InitCoinsDB(
1793 size_t cache_size_bytes,
1805 .cache_bytes = cache_size_bytes,
1806 .memory_only = in_memory,
1807 .wipe_data = should_wipe,
1813 void Chainstate::InitCoinsCache(
size_t cache_size_bytes)
1839 if (chain.Tip() ==
nullptr) {
1848 LogPrintf(
"Leaving InitialBlockDownload (latching to false)\n");
1864 LogPrintf(
"%s: Warning: Found invalid chain at least ~6 blocks longer than our best chain.\nChain state database corruption likely.\n", __func__);
1882 LogPrintf(
"%s: invalid block=%s height=%d log2_work=%f date=%s\n", __func__,
1887 LogPrintf(
"%s: current best=%s height=%d log2_work=%f date=%s\n", __func__,
1942 if (!setup_results)
return false;
1944 const auto [num_elems, approx_size_bytes] = *setup_results;
1945 LogPrintf(
"Using %zu MiB out of %zu MiB requested for script execution cache, able to store %zu elements\n",
1946 approx_size_bytes >> 20, max_size_bytes >> 20, num_elems);
1972 std::vector<CScriptCheck>* pvChecks)
1977 pvChecks->reserve(tx.
vin.size());
1994 std::vector<CTxOut> spent_outputs;
1995 spent_outputs.reserve(tx.
vin.size());
1997 for (
const auto& txin : tx.
vin) {
2001 spent_outputs.emplace_back(coin.
out);
2003 txdata.
Init(tx, std::move(spent_outputs));
2007 for (
unsigned int i = 0; i < tx.
vin.size(); i++) {
2018 pvChecks->emplace_back(std::move(check));
2019 }
else if (!check()) {
2047 if (cacheFullScriptStore && !pvChecks) {
2075 if (undo.nHeight == 0) {
2081 undo.nHeight = alternate.
nHeight;
2106 LogError(
"DisconnectBlock(): failure reading undo data\n");
2110 if (blockUndo.
vtxundo.size() + 1 != block.
vtx.size()) {
2111 LogError(
"DisconnectBlock(): block and undo data inconsistent\n");
2121 bool fEnforceBIP30 = !((pindex->
nHeight==91722 && pindex->
GetBlockHash() ==
uint256S(
"0x00000000000271a2dc26e7667f8419f2e15416dc6955e5a6c6cdf3f2574dd08e")) ||
2122 (pindex->
nHeight==91812 && pindex->
GetBlockHash() ==
uint256S(
"0x00000000000af0aed4792b1acee3d966af36cf5def14935db8de83d6f9306f2f")));
2125 for (
int i = block.
vtx.size() - 1; i >= 0; i--) {
2129 bool is_bip30_exception = (is_coinbase && !fEnforceBIP30);
2133 for (
size_t o = 0; o < tx.
vout.size(); o++) {
2134 if (!tx.
vout[o].scriptPubKey.IsUnspendable()) {
2139 if (!is_bip30_exception) {
2150 LogError(
"DisconnectBlock(): transaction and undo data inconsistent\n");
2153 for (
unsigned int j = tx.
vin.size(); j > 0;) {
2260 const auto time_start{SteadyClock::now()};
2276 if (!
CheckBlock(block, state, params.GetConsensus(), !fJustCheck, !fJustCheck)) {
2295 if (block_hash == params.GetConsensus().hashGenesisBlock) {
2301 bool fScriptChecks =
true;
2310 if (it->second.GetAncestor(pindex->
nHeight) == pindex &&
2332 const auto time_1{SteadyClock::now()};
2335 Ticks<MillisecondsDouble>(time_1 - time_start),
2377 static constexpr
int BIP34_IMPLIES_BIP30_LIMIT = 1983702;
2409 fEnforceBIP30 = fEnforceBIP30 && (!pindexBIP34height || !(pindexBIP34height->
GetBlockHash() == params.GetConsensus().BIP34Hash));
2414 if (fEnforceBIP30 || pindex->
nHeight >= BIP34_IMPLIES_BIP30_LIMIT) {
2415 for (
const auto& tx : block.
vtx) {
2416 for (
size_t o = 0; o < tx->
vout.size(); o++) {
2418 LogPrintf(
"ERROR: ConnectBlock(): tried to overwrite transaction\n");
2426 int nLockTimeFlags = 0;
2434 const auto time_2{SteadyClock::now()};
2437 Ticks<MillisecondsDouble>(time_2 - time_1),
2449 std::vector<PrecomputedTransactionData> txsdata(block.
vtx.size());
2451 std::vector<int> prevheights;
2454 int64_t nSigOpsCost = 0;
2455 blockundo.
vtxundo.reserve(block.
vtx.size() - 1);
2456 for (
unsigned int i = 0; i < block.
vtx.size(); i++)
2460 nInputs += tx.
vin.size();
2475 LogPrintf(
"ERROR: %s: accumulated fee in the block out of range.\n", __func__);
2482 prevheights.resize(tx.
vin.size());
2483 for (
size_t j = 0; j < tx.
vin.size(); j++) {
2487 if (!
SequenceLocks(tx, nLockTimeFlags, prevheights, *pindex)) {
2488 LogPrintf(
"ERROR: %s: contains a non-BIP68-final transaction\n", __func__);
2499 LogPrintf(
"ERROR: ConnectBlock(): too many sigops\n");
2505 std::vector<CScriptCheck> vChecks;
2506 bool fCacheResults = fJustCheck;
2508 if (fScriptChecks && !
CheckInputScripts(tx, tx_state, view,
flags, fCacheResults, fCacheResults, txsdata[i], parallel_script_checks ? &vChecks :
nullptr)) {
2512 LogError(
"ConnectBlock(): CheckInputScripts on %s failed with %s\n",
2516 control.
Add(std::move(vChecks));
2521 blockundo.
vtxundo.emplace_back();
2525 const auto time_3{SteadyClock::now()};
2527 LogPrint(
BCLog::BENCH,
" - Connect %u transactions: %.2fms (%.3fms/tx, %.3fms/txin) [%.2fs (%.2fms/blk)]\n", (
unsigned)block.
vtx.size(),
2528 Ticks<MillisecondsDouble>(time_3 - time_2), Ticks<MillisecondsDouble>(time_3 - time_2) / block.
vtx.size(),
2529 nInputs <= 1 ? 0 : Ticks<MillisecondsDouble>(time_3 - time_2) / (nInputs - 1),
2534 if (block.
vtx[0]->GetValueOut() > blockReward) {
2535 LogPrintf(
"ERROR: ConnectBlock(): coinbase pays too much (actual=%d vs limit=%d)\n", block.
vtx[0]->GetValueOut(), blockReward);
2539 if (!control.
Wait()) {
2540 LogPrintf(
"ERROR: %s: CheckQueue failed\n", __func__);
2543 const auto time_4{SteadyClock::now()};
2545 LogPrint(
BCLog::BENCH,
" - Verify %u txins: %.2fms (%.3fms/txin) [%.2fs (%.2fms/blk)]\n", nInputs - 1,
2546 Ticks<MillisecondsDouble>(time_4 - time_2),
2547 nInputs <= 1 ? 0 : Ticks<MillisecondsDouble>(time_4 - time_2) / (nInputs - 1),
2554 if (!
m_blockman.WriteUndoDataForBlock(blockundo, state, *pindex)) {
2558 const auto time_5{SteadyClock::now()};
2561 Ticks<MillisecondsDouble>(time_5 - time_4),
2573 const auto time_6{SteadyClock::now()};
2576 Ticks<MillisecondsDouble>(time_6 - time_5),
2580 TRACE6(validation, block_connected,
2595 return this->GetCoinsCacheSizeState(
2601 size_t max_coins_cache_size_bytes,
2602 size_t max_mempool_size_bytes)
2607 int64_t nTotalSpace =
2608 max_coins_cache_size_bytes + std::max<int64_t>(int64_t(max_mempool_size_bytes) - nMempoolUsage, 0);
2611 static constexpr int64_t MAX_BLOCK_COINSDB_USAGE_BYTES = 10 * 1024 * 1024;
2612 int64_t large_threshold =
2613 std::max((9 * nTotalSpace) / 10, nTotalSpace - MAX_BLOCK_COINSDB_USAGE_BYTES);
2615 if (cacheSize > nTotalSpace) {
2616 LogPrintf(
"Cache size (%s) exceeds total space (%s)\n", cacheSize, nTotalSpace);
2618 }
else if (cacheSize > large_threshold) {
2624 bool Chainstate::FlushStateToDisk(
2627 int nManualPruneHeight)
2630 assert(this->CanFlushToDisk());
2631 std::set<int> setFilesToPrune;
2632 bool full_flush_completed =
false;
2639 bool fFlushForPrune =
false;
2640 bool fDoFullFlush =
false;
2648 std::optional<std::string> limiting_lock;
2650 for (
const auto& prune_lock :
m_blockman.m_prune_locks) {
2651 if (prune_lock.second.height_first == std::numeric_limits<int>::max())
continue;
2654 last_prune = std::max(1, std::min(last_prune, lock_height));
2655 if (last_prune == lock_height) {
2656 limiting_lock = prune_lock.first;
2660 if (limiting_lock) {
2661 LogPrint(
BCLog::PRUNE,
"%s limited pruning to height %d\n", limiting_lock.value(), last_prune);
2664 if (nManualPruneHeight > 0) {
2669 std::min(last_prune, nManualPruneHeight),
2677 if (!setFilesToPrune.empty()) {
2678 fFlushForPrune =
true;
2680 m_blockman.m_block_tree_db->WriteFlag(
"prunedblockfiles",
true);
2685 const auto nNow{SteadyClock::now()};
2702 fDoFullFlush = (mode ==
FlushStateMode::ALWAYS) || fCacheLarge || fCacheCritical || fPeriodicFlush || fFlushForPrune;
2704 if (fDoFullFlush || fPeriodicWrite) {
2729 if (fFlushForPrune) {
2737 if (fDoFullFlush && !
CoinsTip().GetBestBlock().IsNull()) {
2753 full_flush_completed =
true;
2755 int64_t{Ticks<std::chrono::microseconds>(SteadyClock::now() - nNow)},
2757 (uint64_t)coins_count,
2758 (uint64_t)coins_mem_usage,
2759 (
bool)fFlushForPrune);
2766 }
catch (
const std::runtime_error& e) {
2800 const std::string& func_name,
2801 const std::string&
prefix,
2806 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",
2814 !warning_messages.empty() ?
strprintf(
" warning='%s'", warning_messages) :
"");
2817 void Chainstate::UpdateTip(
const CBlockIndex* pindexNew)
2820 const auto& coins_tip = this->
CoinsTip();
2828 constexpr
int BACKGROUND_LOG_INTERVAL = 2000;
2829 if (pindexNew->
nHeight % BACKGROUND_LOG_INTERVAL == 0) {
2830 UpdateTipLog(coins_tip, pindexNew, params, __func__,
"[background validation] ",
"");
2884 std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
2887 LogError(
"DisconnectTip(): Failed to read block\n");
2891 const auto time_start{SteadyClock::now()};
2895 if (DisconnectBlock(block, pindexDelete, view) !=
DISCONNECT_OK) {
2899 bool flushed = view.
Flush();
2903 Ticks<MillisecondsDouble>(SteadyClock::now() - time_start));
2907 const int max_height_first{pindexDelete->
nHeight - 1};
2908 for (
auto& prune_lock :
m_blockman.m_prune_locks) {
2909 if (prune_lock.second.height_first <= max_height_first)
continue;
2911 prune_lock.second.height_first = max_height_first;
2912 LogPrint(
BCLog::PRUNE,
"%s prune lock moved back to %d\n", prune_lock.first, max_height_first);
2931 UpdateTip(pindexDelete->
pprev);
2998 const auto time_1{SteadyClock::now()};
2999 std::shared_ptr<const CBlock> pthisBlock;
3001 std::shared_ptr<CBlock> pblockNew = std::make_shared<CBlock>();
3005 pthisBlock = pblockNew;
3008 pthisBlock = pblock;
3010 const CBlock& blockConnecting = *pthisBlock;
3012 const auto time_2{SteadyClock::now()};
3013 SteadyClock::time_point time_3;
3017 Ticks<MillisecondsDouble>(time_2 - time_1));
3020 bool rv =
ConnectBlock(blockConnecting, state, pindexNew, view);
3030 time_3 = SteadyClock::now();
3034 Ticks<MillisecondsDouble>(time_3 - time_2),
3037 bool flushed = view.
Flush();
3040 const auto time_4{SteadyClock::now()};
3043 Ticks<MillisecondsDouble>(time_4 - time_3),
3050 const auto time_5{SteadyClock::now()};
3053 Ticks<MillisecondsDouble>(time_5 - time_4),
3063 UpdateTip(pindexNew);
3065 const auto time_6{SteadyClock::now()};
3069 Ticks<MillisecondsDouble>(time_6 - time_5),
3073 Ticks<MillisecondsDouble>(time_6 - time_1),
3082 m_chainman.MaybeCompleteSnapshotValidation();
3110 bool fInvalidAncestor =
false;
3120 if (fFailedChain || fMissingData) {
3127 while (pindexTest != pindexFailed) {
3131 }
else if (fMissingData) {
3136 std::make_pair(pindexFailed->
pprev, pindexFailed));
3139 pindexFailed = pindexFailed->
pprev;
3142 fInvalidAncestor =
true;
3145 pindexTest = pindexTest->
pprev;
3147 if (!fInvalidAncestor)
3179 bool fBlocksDisconnected =
false;
3193 fBlocksDisconnected =
true;
3197 std::vector<CBlockIndex*> vpindexToConnect;
3198 bool fContinue =
true;
3203 int nTargetHeight = std::min(
nHeight + 32, pindexMostWork->
nHeight);
3204 vpindexToConnect.clear();
3205 vpindexToConnect.reserve(nTargetHeight -
nHeight);
3208 vpindexToConnect.push_back(pindexIter);
3209 pindexIter = pindexIter->
pprev;
3215 if (!
ConnectTip(state, pindexConnect, pindexConnect == pindexMostWork ? pblock : std::shared_ptr<const CBlock>(), connectTrace, disconnectpool)) {
3222 fInvalidFound =
true;
3243 if (fBlocksDisconnected) {
3264 bool fNotify =
false;
3265 bool fInitialBlockDownload =
false;
3270 pindexHeader = chainman.m_best_header;
3272 if (pindexHeader != pindexHeaderOld) {
3274 fInitialBlockDownload = chainman.IsInitialBlockDownload();
3275 pindexHeaderOld = pindexHeader;
3288 if (signals.CallbacksPending() > 10) {
3289 signals.SyncWithValidationInterfaceQueue();
3293 bool Chainstate::ActivateBestChain(
BlockValidationState& state, std::shared_ptr<const CBlock> pblock)
3312 LogPrintf(
"m_disabled is set - this chainstate should not be in operation. "
3319 bool exited_ibd{
false};
3332 LOCK(MempoolMutex());
3335 bool blocks_connected =
false;
3341 if (pindexMostWork ==
nullptr) {
3346 if (pindexMostWork ==
nullptr || pindexMostWork ==
m_chain.
Tip()) {
3350 bool fInvalidFound =
false;
3351 std::shared_ptr<const CBlock> nullBlockPtr;
3352 if (!
ActivateBestChainStep(state, pindexMostWork, pblock && pblock->GetHash() == pindexMostWork->
GetBlockHash() ? pblock : nullBlockPtr, fInvalidFound, connectTrace)) {
3356 blocks_connected =
true;
3358 if (fInvalidFound) {
3360 pindexMostWork =
nullptr;
3365 assert(trace.pblock && trace.pindex);
3380 if (!blocks_connected)
return true;
3385 if (was_in_ibd && !still_in_ibd) {
3437 }
while (pindexNewTip != pindexMostWork);
3477 return ActivateBestChain(state, std::shared_ptr<const CBlock>());
3487 if (pindex->
nHeight == 0)
return false;
3490 bool pindex_was_in_chain =
false;
3491 int disconnected = 0;
3505 std::multimap<const arith_uint256, CBlockIndex *> candidate_blocks_by_work;
3509 for (
auto& entry :
m_blockman.m_block_index) {
3520 candidate_blocks_by_work.insert(std::make_pair(candidate->
nChainWork, candidate));
3535 LOCK(MempoolMutex());
3537 pindex_was_in_chain =
true;
3550 if (!
ret)
return false;
3570 auto candidate_it = candidate_blocks_by_work.lower_bound(invalid_walk_tip->
pprev->
nChainWork);
3571 while (candidate_it != candidate_blocks_by_work.end()) {
3574 candidate_it = candidate_blocks_by_work.erase(candidate_it);
3582 to_mark_failed = invalid_walk_tip;
3607 for (
auto& [
_, block_index] :
m_blockman.m_block_index) {
3617 if (pindex_was_in_chain) {
3636 for (
auto& [
_, block_index] :
m_blockman.m_block_index) {
3637 if (!block_index.IsValid() && block_index.GetAncestor(
nHeight) == pindex) {
3643 if (&block_index ==
m_chainman.m_best_invalid) {
3652 while (pindex !=
nullptr) {
3658 pindex = pindex->
pprev;
3672 if (is_active_chainstate) {
3676 }
else if (!m_disabled) {
3681 if (snapshot_base->GetAncestor(pindex->
nHeight) == pindex) {
3691 pindexNew->
nTx = block.
vtx.size();
3697 auto prev_tx_sum = [](
CBlockIndex& block) {
return block.nTx + (block.pprev ? block.pprev->nChainTx : 0); };
3699 pindexNew == GetSnapshotBaseBlock())) {
3700 LogWarning(
"Internal bug detected: block %d has unexpected nChainTx %i that should be %i (%s %s). Please report this issue here: %s\n",
3704 pindexNew->nFile = pos.
nFile;
3705 pindexNew->nDataPos = pos.
nPos;
3706 pindexNew->nUndoPos = 0;
3716 std::deque<CBlockIndex*> queue;
3717 queue.push_back(pindexNew);
3720 while (!queue.empty()) {
3728 LogWarning(
"Internal bug detected: block %d has unexpected nChainTx %i that should be %i (%s %s). Please report this issue here: %s\n",
3731 pindex->
nChainTx = prev_tx_sum(*pindex);
3734 c->TryAddBlockIndexCandidate(pindex);
3736 std::pair<std::multimap<CBlockIndex*, CBlockIndex*>::iterator, std::multimap<CBlockIndex*, CBlockIndex*>::iterator> range =
m_blockman.
m_blocks_unlinked.equal_range(pindex);
3737 while (range.first != range.second) {
3738 std::multimap<CBlockIndex*, CBlockIndex*>::iterator it = range.first;
3739 queue.push_back(it->second);
3770 "hashMerkleRoot mismatch");
3779 "bad-txns-duplicate",
3780 "duplicate transaction");
3795 if (expect_witness_commitment) {
3800 assert(!block.
vtx.empty() && !block.
vtx[0]->vin.empty());
3801 const auto& witness_stack{block.
vtx[0]->vin[0].scriptWitness.stack};
3803 if (witness_stack.size() != 1 || witness_stack[0].size() != 32) {
3806 "bad-witness-nonce-size",
3807 strprintf(
"%s : invalid witness reserved value size", __func__));
3816 if (memcmp(hash_witness.
begin(), &block.
vtx[0]->vout[commitpos].scriptPubKey[6], 32)) {
3819 "bad-witness-merkle-match",
3820 strprintf(
"%s : witness merkle commitment mismatch", __func__));
3829 for (
const auto& tx : block.
vtx) {
3833 "unexpected-witness",
3834 strprintf(
"%s : unexpected witness data found", __func__));
3874 if (block.
vtx.empty() || !block.
vtx[0]->IsCoinBase())
3876 for (
unsigned int i = 1; i < block.
vtx.size(); i++)
3877 if (block.
vtx[i]->IsCoinBase())
3882 for (
const auto& tx : block.
vtx) {
3892 unsigned int nSigOps = 0;
3893 for (
const auto& tx : block.
vtx)
3900 if (fCheckPOW && fCheckMerkleRoot)
3906 void ChainstateManager::UpdateUncommittedBlockStructures(
CBlock& block,
const CBlockIndex* pindexPrev)
const
3909 static const std::vector<unsigned char>
nonce(32, 0x00);
3912 tx.
vin[0].scriptWitness.stack.resize(1);
3913 tx.
vin[0].scriptWitness.stack[0] =
nonce;
3920 std::vector<unsigned char> commitment;
3922 std::vector<unsigned char>
ret(32, 0x00);
3930 out.scriptPubKey[1] = 0x24;
3931 out.scriptPubKey[2] = 0xaa;
3932 out.scriptPubKey[3] = 0x21;
3933 out.scriptPubKey[4] = 0xa9;
3934 out.scriptPubKey[5] = 0xed;
3935 memcpy(&
out.scriptPubKey[6], witnessroot.
begin(), 32);
3936 commitment = std::vector<unsigned char>(
out.scriptPubKey.begin(),
out.scriptPubKey.end());
3941 UpdateUncommittedBlockStructures(block, pindexPrev);
3947 return std::all_of(headers.cbegin(), headers.cend(),
3948 [&](
const auto& header) { return CheckProofOfWork(header.GetHash(), header.nBits, consensusParams);});
3959 if (block.
vtx.empty() || !block.
vtx[0]->IsCoinBase()) {
3966 return std::any_of(block.
vtx.begin(), block.
vtx.end(),
3967 [](
auto& tx) { return GetSerializeSize(TX_NO_WITNESS(tx)) == 64; });
4004 assert(pindexPrev !=
nullptr);
4013 if (chainman.m_options.checkpoints_enabled) {
4017 const CBlockIndex* pcheckpoint = blockman.GetLastCheckpoint(chainman.GetParams().Checkpoints());
4018 if (pcheckpoint && nHeight < pcheckpoint->
nHeight) {
4019 LogPrintf(
"ERROR: %s: forked chain older than last checkpoint (height %d)\n", __func__,
nHeight);
4052 const int nHeight = pindexPrev ==
nullptr ? 0 : pindexPrev->
nHeight + 1;
4055 bool enforce_locktime_median_time_past{
false};
4057 assert(pindexPrev !=
nullptr);
4058 enforce_locktime_median_time_past =
true;
4061 const int64_t nLockTimeCutoff{enforce_locktime_median_time_past ?
4066 for (
const auto& tx : block.
vtx) {
4076 if (block.
vtx[0]->vin[0].scriptSig.size() <
expect.size() ||
4077 !std::equal(
expect.begin(),
expect.end(), block.
vtx[0]->vin[0].scriptSig.begin())) {
4113 BlockMap::iterator miSelf{
m_blockman.m_block_index.find(hash)};
4115 if (miSelf !=
m_blockman.m_block_index.end()) {
4139 pindexPrev = &((*mi).second);
4174 if (pindexPrev->
GetAncestor(failedit->nHeight) == failedit) {
4177 while (invalid_walk != failedit) {
4180 invalid_walk = invalid_walk->
pprev;
4188 if (!min_pow_checked) {
4206 "Saw new header hash=%s height=%d", hash.
ToString(), pindex->
nHeight);
4240 blocks_left = std::max<int64_t>(0, blocks_left);
4241 const double progress{100.0 * last_accepted.nHeight / (last_accepted.nHeight + blocks_left)};
4242 LogInfo(
"Synchronizing blockheaders, height: %d (~%.2f%%)\n", last_accepted.nHeight, progress);
4259 auto now = std::chrono::steady_clock::now();
4260 if (now < m_last_presync_update + std::chrono::milliseconds{250})
return;
4261 m_last_presync_update = now;
4265 if (initial_download) {
4267 blocks_left = std::max<int64_t>(0, blocks_left);
4268 const double progress{100.0 * height / (height + blocks_left)};
4269 LogInfo(
"Pre-synchronizing blockheaders, height: %d (~%.2f%%)\n", height, progress);
4276 const CBlock& block = *pblock;
4278 if (fNewBlock) *fNewBlock =
false;
4282 CBlockIndex *&pindex = ppindex ? *ppindex : pindexDummy;
4284 bool accepted_header{
AcceptBlockHeader(block, state, &pindex, min_pow_checked)};
4287 if (!accepted_header)
4311 if (fAlreadyHave)
return true;
4313 if (pindex->
nTx != 0)
return true;
4314 if (!fHasMoreOrSameWork)
return true;
4315 if (fTooFarAhead)
return true;
4326 if (!
CheckBlock(block, state, params.GetConsensus()) ||
4343 if (fNewBlock) *fNewBlock =
true;
4346 if (blockPos.IsNull()) {
4347 state.
Error(
strprintf(
"%s: Failed to find position to write new block to disk", __func__));
4351 }
catch (
const std::runtime_error& e) {
4375 if (new_block) *new_block =
false;
4390 ret =
AcceptBlock(block, state, &pindex, force_processing,
nullptr, new_block, min_pow_checked);
4405 LogError(
"%s: ActivateBestChain failed (%s)\n", __func__, state.
ToString());
4411 if (bg_chain && !bg_chain->ActivateBestChain(bg_state, block)) {
4412 LogError(
"%s: [background] ActivateBestChain failed (%s)\n", __func__, bg_state.
ToString());
4439 bool fCheckMerkleRoot)
4446 indexDummy.
pprev = pindexPrev;
4452 LogError(
"%s: Consensus::ContextualCheckBlockHeader: %s\n", __func__, state.
ToString());
4460 LogError(
"%s: Consensus::ContextualCheckBlock: %s\n", __func__, state.
ToString());
4463 if (!chainstate.
ConnectBlock(block, state, &indexDummy, viewNew,
true)) {
4475 if (!active_chainstate.FlushStateToDisk(
4501 LogPrintf(
"Loaded best chain: hashBestChain=%s height=%d date=%s progress=%f\n",
4524 int nCheckLevel,
int nCheckDepth)
4533 if (nCheckDepth <= 0 || nCheckDepth > chainstate.
m_chain.
Height()) {
4536 nCheckLevel = std::max(0, std::min(4, nCheckLevel));
4537 LogPrintf(
"Verifying last %i blocks at level %i\n", nCheckDepth, nCheckLevel);
4541 int nGoodTransactions = 0;
4544 bool skipped_no_block_data{
false};
4545 bool skipped_l3_checks{
false};
4546 LogPrintf(
"Verification progress: 0%%\n");
4551 const int percentageDone = std::max(1, std::min(99, (
int)(((
double)(chainstate.
m_chain.
Height() - pindex->
nHeight)) / (
double)nCheckDepth * (nCheckLevel >= 4 ? 50 : 100))));
4552 if (reportDone < percentageDone / 10) {
4554 LogPrintf(
"Verification progress: %d%%\n", percentageDone);
4555 reportDone = percentageDone / 10;
4564 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);
4565 skipped_no_block_data =
true;
4575 if (nCheckLevel >= 1 && !
CheckBlock(block, state, consensus_params)) {
4576 LogPrintf(
"Verification error: found bad block at %d, hash=%s (%s)\n",
4581 if (nCheckLevel >= 2 && pindex) {
4593 if (nCheckLevel >= 3) {
4602 nGoodTransactions = 0;
4603 pindexFailure = pindex;
4605 nGoodTransactions += block.
vtx.size();
4608 skipped_l3_checks =
true;
4613 if (pindexFailure) {
4614 LogPrintf(
"Verification error: coin database inconsistencies found (last %i blocks, %i good transactions before that)\n", chainstate.
m_chain.
Height() - pindexFailure->
nHeight + 1, nGoodTransactions);
4617 if (skipped_l3_checks) {
4618 LogPrintf(
"Skipped verification of level >=3 (insufficient database cache size). Consider increasing -dbcache.\n");
4625 if (nCheckLevel >= 4 && !skipped_l3_checks) {
4627 const int percentageDone = std::max(1, std::min(99, 100 - (
int)(((
double)(chainstate.
m_chain.
Height() - pindex->
nHeight)) / (
double)nCheckDepth * 50)));
4628 if (reportDone < percentageDone / 10) {
4630 LogPrintf(
"Verification progress: %d%%\n", percentageDone);
4631 reportDone = percentageDone / 10;
4640 if (!chainstate.
ConnectBlock(block, state, pindex, coins)) {
4648 LogPrintf(
"Verification: No coin database inconsistencies in last %i blocks (%i transactions)\n", block_count, nGoodTransactions);
4650 if (skipped_l3_checks) {
4653 if (skipped_no_block_data) {
4671 if (!tx->IsCoinBase()) {
4672 for (
const CTxIn &txin : tx->vin) {
4690 if (hashHeads.empty())
return true;
4691 if (hashHeads.size() != 2) {
4692 LogError(
"ReplayBlocks(): unknown inconsistent state\n");
4703 if (
m_blockman.m_block_index.count(hashHeads[0]) == 0) {
4704 LogError(
"ReplayBlocks(): reorganization to unknown block requested\n");
4707 pindexNew = &(
m_blockman.m_block_index[hashHeads[0]]);
4709 if (!hashHeads[1].IsNull()) {
4710 if (
m_blockman.m_block_index.count(hashHeads[1]) == 0) {
4711 LogError(
"ReplayBlocks(): reorganization from unknown block requested\n");
4714 pindexOld = &(
m_blockman.m_block_index[hashHeads[1]]);
4716 assert(pindexFork !=
nullptr);
4720 while (pindexOld != pindexFork) {
4738 pindexOld = pindexOld->
pprev;
4742 int nForkHeight = pindexFork ? pindexFork->
nHeight : 0;
4769 block = block->pprev;
4775 void Chainstate::ClearBlockIndexCandidates()
4788 if (!
ret)
return false;
4790 m_blockman.ScanAndUnlinkAlreadyPrunedFiles();
4792 std::vector<CBlockIndex*> vSortedByHeight{
m_blockman.GetAllBlockIndices()};
4793 std::sort(vSortedByHeight.begin(), vSortedByHeight.end(),
4803 if (pindex == GetSnapshotBaseBlock() ||
4808 chainstate->TryAddBlockIndexCandidate(pindex);
4812 m_best_invalid = pindex;
4815 m_best_header = pindex;
4818 needs_init =
m_blockman.m_block_index.empty();
4828 LogPrintf(
"Initializing databases...\n");
4843 if (
m_blockman.m_block_index.count(params.GenesisBlock().GetHash()))
4847 const CBlock& block = params.GenesisBlock();
4849 if (blockPos.IsNull()) {
4850 LogError(
"%s: writing genesis block to disk failed\n", __func__);
4855 }
catch (
const std::runtime_error& e) {
4856 LogError(
"%s: failed to write genesis block: %s\n", __func__, e.what());
4866 std::multimap<uint256, FlatFilePos>* blocks_with_unknown_parent)
4869 assert(!dbp == !blocks_with_unknown_parent);
4871 const auto start{SteadyClock::now()};
4879 uint64_t nRewind = blkdat.GetPos();
4880 while (!blkdat.eof()) {
4883 blkdat.SetPos(nRewind);
4886 unsigned int nSize = 0;
4890 blkdat.FindByte(std::byte(params.MessageStart()[0]));
4891 nRewind = blkdat.GetPos() + 1;
4893 if (buf != params.MessageStart()) {
4900 }
catch (
const std::exception&) {
4907 const uint64_t nBlockPos{blkdat.GetPos()};
4909 dbp->
nPos = nBlockPos;
4910 blkdat.SetLimit(nBlockPos + nSize);
4916 nRewind = nBlockPos + nSize;
4917 blkdat.SkipTo(nRewind);
4919 std::shared_ptr<CBlock> pblock{};
4927 if (dbp && blocks_with_unknown_parent) {
4928 blocks_with_unknown_parent->emplace(header.
hashPrevBlock, *dbp);
4937 blkdat.SetPos(nBlockPos);
4938 pblock = std::make_shared<CBlock>();
4940 nRewind = blkdat.GetPos();
4943 if (
AcceptBlock(pblock, state,
nullptr,
true, dbp,
nullptr,
true)) {
4949 }
else if (hash != params.GetConsensus().hashGenesisBlock && pindex->
nHeight % 1000 == 0) {
4955 if (hash == params.GetConsensus().hashGenesisBlock) {
4956 bool genesis_activation_failure =
false;
4957 for (
auto c :
GetAll()) {
4959 if (!c->ActivateBestChain(state,
nullptr)) {
4960 genesis_activation_failure =
true;
4964 if (genesis_activation_failure) {
4977 bool activation_failure =
false;
4978 for (
auto c :
GetAll()) {
4980 if (!c->ActivateBestChain(state, pblock)) {
4982 activation_failure =
true;
4986 if (activation_failure) {
4993 if (!blocks_with_unknown_parent)
continue;
4996 std::deque<uint256> queue;
4997 queue.push_back(hash);
4998 while (!queue.empty()) {
5001 auto range = blocks_with_unknown_parent->equal_range(head);
5002 while (range.first != range.second) {
5003 std::multimap<uint256, FlatFilePos>::iterator it = range.first;
5004 std::shared_ptr<CBlock> pblockrecursive = std::make_shared<CBlock>();
5006 LogPrint(
BCLog::REINDEX,
"%s: Processing out of order child %s of %s\n", __func__, pblockrecursive->GetHash().ToString(),
5010 if (
AcceptBlock(pblockrecursive, dummy,
nullptr,
true, &it->second,
nullptr,
true)) {
5012 queue.push_back(pblockrecursive->GetHash());
5016 blocks_with_unknown_parent->erase(it);
5020 }
catch (
const std::exception& e) {
5032 LogPrint(
BCLog::REINDEX,
"%s: unexpected data at file offset 0x%x - %s. continuing\n", __func__, (nRewind - 1), e.what());
5035 }
catch (
const std::runtime_error& e) {
5038 LogPrintf(
"Loaded %i blocks from external file in %dms\n", nLoaded, Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
5058 std::multimap<CBlockIndex*,CBlockIndex*> forward;
5059 for (
auto& [
_, block_index] :
m_blockman.m_block_index) {
5060 forward.emplace(block_index.pprev, &block_index);
5065 std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> rangeGenesis = forward.equal_range(
nullptr);
5067 rangeGenesis.first++;
5068 assert(rangeGenesis.first == rangeGenesis.second);
5079 CBlockIndex* pindexFirstNotTransactionsValid =
nullptr;
5081 CBlockIndex* pindexFirstNotScriptsValid =
nullptr;
5087 const CBlockIndex* snap_base{GetSnapshotBaseBlock()};
5088 CBlockIndex *snap_first_missing{}, *snap_first_notx{}, *snap_first_notv{}, *snap_first_nocv{}, *snap_first_nosv{};
5089 auto snap_update_firsts = [&] {
5090 if (pindex == snap_base) {
5091 std::swap(snap_first_missing, pindexFirstMissing);
5092 std::swap(snap_first_notx, pindexFirstNeverProcessed);
5093 std::swap(snap_first_notv, pindexFirstNotTransactionsValid);
5094 std::swap(snap_first_nocv, pindexFirstNotChainValid);
5095 std::swap(snap_first_nosv, pindexFirstNotScriptsValid);
5099 while (pindex !=
nullptr) {
5101 if (pindexFirstInvalid ==
nullptr && pindex->nStatus &
BLOCK_FAILED_VALID) pindexFirstInvalid = pindex;
5102 if (pindexFirstMissing ==
nullptr && !(pindex->nStatus &
BLOCK_HAVE_DATA)) {
5103 pindexFirstMissing = pindex;
5105 if (pindexFirstNeverProcessed ==
nullptr && pindex->
nTx == 0) pindexFirstNeverProcessed = pindex;
5108 if (pindex->
pprev !=
nullptr) {
5109 if (pindexFirstNotTransactionsValid ==
nullptr &&
5111 pindexFirstNotTransactionsValid = pindex;
5114 if (pindexFirstNotChainValid ==
nullptr &&
5116 pindexFirstNotChainValid = pindex;
5119 if (pindexFirstNotScriptsValid ==
nullptr &&
5121 pindexFirstNotScriptsValid = pindex;
5126 if (pindex->
pprev ==
nullptr) {
5129 for (
auto c :
GetAll()) {
5130 if (c->m_chain.Genesis() !=
nullptr) {
5131 assert(pindex == c->m_chain.Genesis());
5141 assert(pindexFirstMissing == pindexFirstNeverProcessed);
5147 if (snap_base && snap_base->GetAncestor(pindex->
nHeight) == pindex) {
5157 assert((pindexFirstNotTransactionsValid ==
nullptr || pindex == snap_base) == pindex->
HaveNumChainTxs());
5161 assert(pindexFirstNotTreeValid ==
nullptr);
5165 if (pindexFirstInvalid ==
nullptr) {
5170 if (!pindex->
pprev) {
5183 for (
auto c :
GetAll()) {
5184 if (c->m_chain.Tip() ==
nullptr)
continue;
5198 if (!
CBlockIndexWorkComparator()(pindex, c->m_chain.Tip()) && (pindexFirstNeverProcessed ==
nullptr || pindex == snap_base)) {
5202 if (pindexFirstInvalid ==
nullptr) {
5221 if (pindexFirstMissing ==
nullptr || pindex == c->m_chain.Tip() || pindex == c->SnapshotBase()) {
5228 assert(c->setBlockIndexCandidates.count(pindex));
5236 assert(c->setBlockIndexCandidates.count(pindex) == 0);
5240 std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> rangeUnlinked =
m_blockman.
m_blocks_unlinked.equal_range(pindex->
pprev);
5241 bool foundInUnlinked =
false;
5242 while (rangeUnlinked.first != rangeUnlinked.second) {
5243 assert(rangeUnlinked.first->first == pindex->
pprev);
5244 if (rangeUnlinked.first->second == pindex) {
5245 foundInUnlinked =
true;
5248 rangeUnlinked.first++;
5250 if (pindex->
pprev && (pindex->nStatus &
BLOCK_HAVE_DATA) && pindexFirstNeverProcessed !=
nullptr && pindexFirstInvalid ==
nullptr) {
5255 if (pindexFirstMissing ==
nullptr)
assert(!foundInUnlinked);
5256 if (pindex->
pprev && (pindex->nStatus &
BLOCK_HAVE_DATA) && pindexFirstNeverProcessed ==
nullptr && pindexFirstMissing !=
nullptr) {
5267 for (
auto c :
GetAll()) {
5270 if (pindexFirstInvalid ==
nullptr) {
5271 if (is_active || snap_base->GetAncestor(pindex->
nHeight) == pindex) {
5282 snap_update_firsts();
5283 std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> range = forward.equal_range(pindex);
5284 if (range.first != range.second) {
5286 pindex = range.first->second;
5294 snap_update_firsts();
5296 if (pindex == pindexFirstInvalid) pindexFirstInvalid =
nullptr;
5297 if (pindex == pindexFirstMissing) pindexFirstMissing =
nullptr;
5298 if (pindex == pindexFirstNeverProcessed) pindexFirstNeverProcessed =
nullptr;
5299 if (pindex == pindexFirstNotTreeValid) pindexFirstNotTreeValid =
nullptr;
5300 if (pindex == pindexFirstNotTransactionsValid) pindexFirstNotTransactionsValid =
nullptr;
5301 if (pindex == pindexFirstNotChainValid) pindexFirstNotChainValid =
nullptr;
5302 if (pindex == pindexFirstNotScriptsValid) pindexFirstNotScriptsValid =
nullptr;
5306 std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> rangePar = forward.equal_range(pindexPar);
5307 while (rangePar.first->second != pindex) {
5308 assert(rangePar.first != rangePar.second);
5313 if (rangePar.first != rangePar.second) {
5315 pindex = rangePar.first->second;
5327 assert(nNodes == forward.size());
5334 return strprintf(
"Chainstate [%s] @ height %d (%s)",
5339 bool Chainstate::ResizeCoinsCaches(
size_t coinstip_size,
size_t coinsdb_size)
5352 LogPrintf(
"[%s] resized coinsdb cache to %.1f MiB\n",
5353 this->
ToString(), coinsdb_size * (1.0 / 1024 / 1024));
5354 LogPrintf(
"[%s] resized coinstip cache to %.1f MiB\n",
5355 this->
ToString(), coinstip_size * (1.0 / 1024 / 1024));
5360 if (coinstip_size > old_coinstip_size) {
5373 if (pindex ==
nullptr)
5377 LogWarning(
"Internal bug detected: block %d has unset nChainTx (%s %s). Please report this issue here: %s\n",
5382 int64_t nNow = time(
nullptr);
5392 return std::min<double>(pindex->
nChainTx / fTxTotal, 1.0);
5398 if (m_active_chainstate && m_active_chainstate->m_from_snapshot_blockhash) {
5400 return m_active_chainstate->m_from_snapshot_blockhash;
5402 return std::nullopt;
5408 std::vector<Chainstate*>
out;
5410 for (
Chainstate*
cs : {m_ibd_chainstate.get(), m_snapshot_chainstate.get()}) {
5420 assert(!m_ibd_chainstate);
5421 assert(!m_active_chainstate);
5423 m_ibd_chainstate = std::make_unique<Chainstate>(mempool,
m_blockman, *
this);
5424 m_active_chainstate = m_ibd_chainstate.get();
5425 return *m_active_chainstate;
5437 bool existed = fs::remove(base_blockhash_path);
5439 LogPrintf(
"[snapshot] snapshot chainstate dir being removed lacks %s file\n",
5442 }
catch (
const fs::filesystem_error& e) {
5443 LogPrintf(
"[snapshot] failed to remove file %s: %s\n",
5449 LogPrintf(
"Removing leveldb dir at %s\n", path_str);
5453 const bool destroyed =
DestroyDB(path_str);
5456 LogPrintf(
"error: leveldb DestroyDB call failed on %s\n", path_str);
5476 LogPrintf(
"[snapshot] can't activate a snapshot-based chainstate more than once\n");
5482 if (
Assert(m_active_chainstate->GetMempool())->size() > 0) {
5483 LogPrintf(
"[snapshot] can't activate a snapshot when mempool not empty\n");
5488 int64_t current_coinsdb_cache_size{0};
5489 int64_t current_coinstip_cache_size{0};
5497 static constexpr
double IBD_CACHE_PERC = 0.01;
5498 static constexpr
double SNAPSHOT_CACHE_PERC = 0.99;
5510 current_coinsdb_cache_size = this->
ActiveChainstate().m_coinsdb_cache_size_bytes;
5511 current_coinstip_cache_size = this->
ActiveChainstate().m_coinstip_cache_size_bytes;
5516 static_cast<size_t>(current_coinstip_cache_size * IBD_CACHE_PERC),
5517 static_cast<size_t>(current_coinsdb_cache_size * IBD_CACHE_PERC));
5521 return std::make_unique<Chainstate>(
5522 nullptr,
m_blockman, *
this, base_blockhash));
5526 snapshot_chainstate->InitCoinsDB(
5527 static_cast<size_t>(current_coinsdb_cache_size * SNAPSHOT_CACHE_PERC),
5528 in_memory,
false,
"chainstate");
5529 snapshot_chainstate->InitCoinsCache(
5530 static_cast<size_t>(current_coinstip_cache_size * SNAPSHOT_CACHE_PERC));
5534 LogPrintf(
"[snapshot] activation failed - %s\n", reason);
5535 this->MaybeRebalanceCaches();
5543 snapshot_chainstate.reset();
5547 "Manually remove it before restarting.\n"),
fs::PathToString(*snapshot_datadir)));
5555 return cleanup_bad_snapshot(
"population failed");
5564 return cleanup_bad_snapshot(
"work does not exceed active chainstate");
5570 return cleanup_bad_snapshot(
"could not write base blockhash");
5574 assert(!m_snapshot_chainstate);
5575 m_snapshot_chainstate.swap(snapshot_chainstate);
5576 const bool chaintip_loaded = m_snapshot_chainstate->LoadChainTip();
5581 Assert(m_active_chainstate->m_mempool->size() == 0);
5582 Assert(!m_snapshot_chainstate->m_mempool);
5583 m_snapshot_chainstate->m_mempool = m_active_chainstate->m_mempool;
5584 m_active_chainstate->m_mempool =
nullptr;
5585 m_active_chainstate = m_snapshot_chainstate.get();
5588 LogPrintf(
"[snapshot] successfully activated snapshot %s\n", base_blockhash.
ToString());
5590 m_snapshot_chainstate->CoinsTip().DynamicMemoryUsage() / (1000 * 1000));
5592 this->MaybeRebalanceCaches();
5600 snapshot_loaded ?
"saving snapshot chainstate" :
"flushing coins cache",
5604 coins_cache.
Flush();
5609 const char*
what() const noexcept
override
5611 return "ComputeUTXOStats interrupted.";
5633 if (!snapshot_start_block) {
5636 LogPrintf(
"[snapshot] Did not find snapshot start blockheader %s\n",
5641 int base_height = snapshot_start_block->
nHeight;
5644 if (!maybe_au_data) {
5645 LogPrintf(
"[snapshot] assumeutxo height in snapshot metadata not recognized "
5646 "(%d) - refusing to load snapshot\n", base_height);
5656 LogPrintf(
"[snapshot] activation failed - work does not exceed active chainstate\n");
5665 LogPrintf(
"[snapshot] loading coins from snapshot %s\n", base_blockhash.
ToString());
5666 int64_t coins_processed{0};
5668 while (coins_left > 0) {
5670 coins_file >> outpoint;
5672 }
catch (
const std::ios_base::failure&) {
5673 LogPrintf(
"[snapshot] bad snapshot format or truncated snapshot after deserializing %d coins\n",
5674 coins_count - coins_left);
5677 if (coin.
nHeight > base_height ||
5678 outpoint.
n >= std::numeric_limits<decltype(outpoint.
n)>::max()
5680 LogPrintf(
"[snapshot] bad snapshot data after deserializing %d coins\n",
5681 coins_count - coins_left);
5685 LogPrintf(
"[snapshot] bad snapshot data after deserializing %d coins - bad tx out value\n",
5686 coins_count - coins_left);
5695 if (coins_processed % 1000000 == 0) {
5696 LogPrintf(
"[snapshot] %d coins loaded (%.2f%%, %.2f MB)\n",
5698 static_cast<float>(coins_processed) * 100 /
static_cast<float>(coins_count),
5706 if (coins_processed % 120000 == 0) {
5712 return snapshot_chainstate.GetCoinsCacheSizeState());
5733 bool out_of_coins{
false};
5735 coins_file >> outpoint;
5736 }
catch (
const std::ios_base::failure&) {
5738 out_of_coins =
true;
5740 if (!out_of_coins) {
5741 LogPrintf(
"[snapshot] bad snapshot - coins left over after deserializing %d coins\n",
5746 LogPrintf(
"[snapshot] loaded %d (%.2f MB) coins from snapshot %s\n",
5760 std::optional<CCoinsStats> maybe_stats;
5768 if (!maybe_stats.has_value()) {
5769 LogPrintf(
"[snapshot] failed to generate coins stats\n");
5775 LogPrintf(
"[snapshot] bad snapshot content hash: expected %s, got %s\n",
5791 constexpr
int AFTER_GENESIS_START{1};
5793 for (
int i = AFTER_GENESIS_START; i <= snapshot_chainstate.
m_chain.
Height(); ++i) {
5794 index = snapshot_chainstate.
m_chain[i];
5811 assert(index == snapshot_start_block);
5815 LogPrintf(
"[snapshot] validated snapshot (%.2f MB)\n",
5837 if (m_ibd_chainstate.get() == &this->ActiveChainstate() ||
5838 !this->IsUsable(m_snapshot_chainstate.get()) ||
5839 !this->IsUsable(m_ibd_chainstate.get()) ||
5840 !m_ibd_chainstate->m_chain.Tip()) {
5846 const int snapshot_base_height = *
Assert(this->GetSnapshotBaseHeight());
5849 if (index_new.
nHeight < snapshot_base_height) {
5859 "%s failed to validate the -assumeutxo snapshot state. "
5860 "This indicates a hardware problem, or a bug in the software, or a "
5861 "bad software modification that allowed an invalid snapshot to be "
5862 "loaded. As a result of this, the node will shut down and stop using any "
5863 "state that was built on the snapshot, resetting the chain height "
5864 "from %d to %d. On the next "
5865 "restart, the node will resume syncing from %d "
5866 "without using any snapshot data. "
5867 "Please report this incident to %s, including how you obtained the snapshot. "
5868 "The invalid snapshot chainstate will be left on disk in case it is "
5869 "helpful in diagnosing the issue that caused this error."),
5874 LogPrintf(
"[snapshot] deleting snapshot, reverting to validated chain, and stopping node\n");
5876 m_active_chainstate = m_ibd_chainstate.get();
5877 m_snapshot_chainstate->m_disabled =
true;
5881 auto rename_result = m_snapshot_chainstate->InvalidateCoinsDBOnDisk();
5882 if (!rename_result) {
5890 LogPrintf(
"[snapshot] supposed base block %s does not match the "
5891 "snapshot base block %s (height %d). Snapshot is not valid.\n",
5892 index_new.
ToString(), snapshot_blockhash.
ToString(), snapshot_base_height);
5893 handle_invalid_snapshot();
5899 int curr_height = m_ibd_chainstate->m_chain.Height();
5901 assert(snapshot_base_height == curr_height);
5906 CCoinsViewDB& ibd_coins_db = m_ibd_chainstate->CoinsDB();
5907 m_ibd_chainstate->ForceFlushStateToDisk();
5910 if (!maybe_au_data) {
5911 LogPrintf(
"[snapshot] assumeutxo data not found for height "
5912 "(%d) - refusing to validate snapshot\n", curr_height);
5913 handle_invalid_snapshot();
5918 std::optional<CCoinsStats> maybe_ibd_stats;
5919 LogPrintf(
"[snapshot] computing UTXO stats for background chainstate to validate "
5920 "snapshot - this could take a few minutes\n");
5923 CoinStatsHashType::HASH_SERIALIZED,
5932 if (!maybe_ibd_stats) {
5933 LogPrintf(
"[snapshot] failed to generate stats for validation coins db\n");
5937 handle_invalid_snapshot();
5940 const auto& ibd_stats = *maybe_ibd_stats;
5949 LogPrintf(
"[snapshot] hash mismatch: actual=%s, expected=%s\n",
5950 ibd_stats.hashSerialized.ToString(),
5952 handle_invalid_snapshot();
5956 LogPrintf(
"[snapshot] snapshot beginning at %s has been fully validated\n",
5959 m_ibd_chainstate->m_disabled =
true;
5960 this->MaybeRebalanceCaches();
5968 assert(m_active_chainstate);
5969 return *m_active_chainstate;
5975 return m_snapshot_chainstate && m_active_chainstate == m_snapshot_chainstate.get();
5978 void ChainstateManager::MaybeRebalanceCaches()
5981 bool ibd_usable = this->
IsUsable(m_ibd_chainstate.get());
5982 bool snapshot_usable = this->
IsUsable(m_snapshot_chainstate.get());
5983 assert(ibd_usable || snapshot_usable);
5985 if (ibd_usable && !snapshot_usable) {
5990 else if (snapshot_usable && !ibd_usable) {
5992 LogPrintf(
"[snapshot] allocating all cache to the snapshot chainstate\n");
5996 else if (ibd_usable && snapshot_usable) {
6001 m_ibd_chainstate->ResizeCoinsCaches(
6003 m_snapshot_chainstate->ResizeCoinsCaches(
6006 m_snapshot_chainstate->ResizeCoinsCaches(
6008 m_ibd_chainstate->ResizeCoinsCaches(
6014 void ChainstateManager::ResetChainstates()
6016 m_ibd_chainstate.reset();
6017 m_snapshot_chainstate.reset();
6018 m_active_chainstate =
nullptr;
6028 if (!opts.check_block_index.has_value()) opts.
check_block_index = opts.chainparams.DefaultConsistencyChecks();
6029 if (!opts.minimum_chain_work.has_value()) opts.minimum_chain_work =
UintToArith256(opts.chainparams.GetConsensus().nMinimumChainWork);
6030 if (!opts.assumed_valid_block.has_value()) opts.assumed_valid_block = opts.chainparams.GetConsensus().defaultAssumeValid;
6031 return std::move(opts);
6035 : m_script_check_queue{128, options.worker_threads_num},
6036 m_interrupt{interrupt},
6038 m_blockman{interrupt,
std::move(blockman_options)}
6049 bool ChainstateManager::DetectSnapshotChainstate()
6051 assert(!m_snapshot_chainstate);
6057 if (!base_blockhash) {
6060 LogPrintf(
"[snapshot] detected active snapshot chainstate (%s) - loading\n",
6063 this->ActivateExistingSnapshot(*base_blockhash);
6069 assert(!m_snapshot_chainstate);
6070 m_snapshot_chainstate =
6071 std::make_unique<Chainstate>(
nullptr,
m_blockman, *
this, base_blockhash);
6072 LogPrintf(
"[snapshot] switching active chainstate to %s\n", m_snapshot_chainstate->ToString());
6075 Assert(m_active_chainstate->m_mempool->size() == 0);
6076 Assert(!m_snapshot_chainstate->m_mempool);
6077 m_snapshot_chainstate->m_mempool = m_active_chainstate->m_mempool;
6078 m_active_chainstate->m_mempool =
nullptr;
6079 m_active_chainstate = m_snapshot_chainstate.get();
6080 return *m_snapshot_chainstate;
6085 return (block_index.
nHeight==91842 && block_index.
GetBlockHash() ==
uint256S(
"0x00000000000a4d0a398161ffc163c503763b1f4360639393e0e4c8e300e0caec")) ||
6086 (block_index.
nHeight==91880 && block_index.
GetBlockHash() ==
uint256S(
"0x00000000000743f190a18c5577a3c2d2a1f610ae9601ac046a38084ccb7cd721"));
6091 return (block_index.
nHeight==91722 && block_index.
GetBlockHash() ==
uint256S(
"0x00000000000271a2dc26e7667f8419f2e15416dc6955e5a6c6cdf3f2574dd08e")) ||
6092 (block_index.
nHeight==91812 && block_index.
GetBlockHash() ==
uint256S(
"0x00000000000af0aed4792b1acee3d966af36cf5def14935db8de83d6f9306f2f"));
6099 assert(
cs.m_from_snapshot_blockhash);
6100 auto storage_path_maybe =
cs.CoinsDB().StoragePath();
6102 assert(storage_path_maybe);
6103 return *storage_path_maybe;
6113 auto invalid_path = snapshot_datadir +
"_INVALID";
6116 LogPrintf(
"[snapshot] renaming snapshot datadir %s to %s\n", dbpath, target);
6122 fs::rename(snapshot_datadir, invalid_path);
6123 }
catch (
const fs::filesystem_error& e) {
6127 LogPrintf(
"%s: error renaming file '%s' -> '%s': %s\n",
6128 __func__, src_str, dest_str, e.what());
6130 "Rename of '%s' -> '%s' failed. "
6131 "You should resolve this by manually moving or deleting the invalid "
6132 "snapshot directory %s, otherwise you will encounter the same error again "
6133 "on the next startup."),
6134 src_str, dest_str, src_str)};
6139 bool ChainstateManager::DeleteSnapshotChainstate()
6142 Assert(m_snapshot_chainstate);
6143 Assert(m_ibd_chainstate);
6147 LogPrintf(
"Deletion of %s failed. Please remove it manually to continue reindexing.\n",
6151 m_active_chainstate = m_ibd_chainstate.get();
6152 m_active_chainstate->m_mempool = m_snapshot_chainstate->m_mempool;
6153 m_snapshot_chainstate.reset();
6167 const CBlockIndex* ChainstateManager::GetSnapshotBaseBlock()
const
6169 return m_active_chainstate ? m_active_chainstate->SnapshotBase() :
nullptr;
6172 std::optional<int> ChainstateManager::GetSnapshotBaseHeight()
const
6174 const CBlockIndex* base = this->GetSnapshotBaseBlock();
6175 return base ? std::make_optional(base->
nHeight) :
std::nullopt;
6178 bool ChainstateManager::ValidatedSnapshotCleanup()
6182 if (!(chainstate && chainstate->HasCoinsViews())) {
6185 return chainstate->CoinsDB().StoragePath();
6187 std::optional<fs::path> ibd_chainstate_path_maybe = get_storage_path(m_ibd_chainstate);
6188 std::optional<fs::path> snapshot_chainstate_path_maybe = get_storage_path(m_snapshot_chainstate);
6197 if (!ibd_chainstate_path_maybe || !snapshot_chainstate_path_maybe) {
6198 LogPrintf(
"[snapshot] snapshot chainstate cleanup cannot happen with "
6199 "in-memory chainstates. You are testing, right?\n");
6203 const auto& snapshot_chainstate_path = *snapshot_chainstate_path_maybe;
6204 const auto& ibd_chainstate_path = *ibd_chainstate_path_maybe;
6212 this->ResetChainstates();
6217 LogPrintf(
"[snapshot] deleting background chainstate directory (now unnecessary) (%s)\n",
6220 fs::path tmp_old{ibd_chainstate_path +
"_todelete"};
6222 auto rename_failed_abort = [
this](
6225 const fs::filesystem_error& err) {
6226 LogPrintf(
"Error renaming path (%s) -> (%s): %s\n",
6229 "Rename of '%s' -> '%s' failed. "
6230 "Cannot clean up the background chainstate leveldb directory."),
6235 fs::rename(ibd_chainstate_path, tmp_old);
6236 }
catch (
const fs::filesystem_error& e) {
6237 rename_failed_abort(ibd_chainstate_path, tmp_old, e);
6241 LogPrintf(
"[snapshot] moving snapshot chainstate (%s) to "
6242 "default chainstate directory (%s)\n",
6246 fs::rename(snapshot_chainstate_path, ibd_chainstate_path);
6247 }
catch (
const fs::filesystem_error& e) {
6248 rename_failed_abort(snapshot_chainstate_path, ibd_chainstate_path, e);
6255 LogPrintf(
"Deletion of %s failed. Please remove it manually, as the "
6256 "directory is now unnecessary.\n",
6259 LogPrintf(
"[snapshot] deleted background chainstate directory (%s)\n",
6265 Chainstate& ChainstateManager::GetChainstateForIndexing()
6270 return (this->
GetAll().size() > 1) ? *m_ibd_chainstate : *m_active_chainstate;
6273 std::pair<int, int> ChainstateManager::GetPruneRange(
const Chainstate& chainstate,
int last_height_can_prune)
6280 if (this->
GetAll().size() > 1 && m_snapshot_chainstate.get() == &chainstate) {
6283 prune_start = *
Assert(GetSnapshotBaseHeight()) + 1;
6286 int max_prune = std::max<int>(
6295 int prune_end = std::min(last_height_can_prune, max_prune);
6297 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.
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...
void Add(std::vector< T > &&vChecks)
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)
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
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)
const int64_t m_max_size_bytes
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
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...
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?
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())
bool ActivateSnapshot(AutoFile &coins_file, const node::SnapshotMetadata &metadata, bool in_memory)
Construct and activate a Chainstate on the basis of UTXO snapshot data.
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.
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
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)
cache implements a cache with properties similar to a cuckoo-set.
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.
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 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 warning(const bilingual_str &warning)
virtual void progress(const bilingual_str &title, int progress_percent, bool resume_possible)
virtual InterruptResult blockTip(SynchronizationState state, CBlockIndex &index)
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 WriteUndoDataForBlock(const CBlockUndo &blockundo, BlockValidationState &state, CBlockIndex &block) EXCLUSIVE_LOCKS_REQUIRED(FlatFilePos SaveBlockToDisk(const CBlock &block, int nHeight, const FlatFilePos *dbp)
Store block on disk.
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...
CBlockIndex * LookupBlockIndex(const uint256 &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
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
bool CheckBlockDataAvailability(const CBlockIndex &upper_block LIFETIMEBOUND, const CBlockIndex &lower_block LIFETIMEBOUND) EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex *GetFirstStoredBlock(const CBlockIndex &start_block LIFETIMEBOUND, const CBlockIndex *lower_block=nullptr) EXCLUSIVE_LOCKS_REQUIRED(boo m_have_pruned)
Check if all blocks in the [upper_block, lower_block] range have data available.
void UnlinkPrunedFiles(const std::set< int > &setFilesToPrune) const
Actually unlink the specified files.
bool WriteBlockIndexDB() EXCLUSIVE_LOCKS_REQUIRED(bool LoadBlockIndexDB(const std::optional< uint256 > &snapshot_blockhash) EXCLUSIVE_LOCKS_REQUIRED(void ScanAndUnlinkAlreadyPrunedFiles() EXCLUSIVE_LOCKS_REQUIRED(CBlockIndex * AddToBlockIndex(const CBlockHeader &block, CBlockIndex *&best_header) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Remove any pruned block & undo files that are still on disk.
bool 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
constexpr const std::byte * data() 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
std::string FormatMoney(const CAmount n)
Money parsing/formatting utilities.
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)
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.
std::atomic_bool fReindex
bilingual_str ErrorString(const Result< T > &result)
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::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
reverse_range< T > reverse_iterate(T &x)
std::string ScriptErrorString(const ScriptError serror)
size_t GetSerializeSize(const T &t)
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)
std::string ToString(const T &t)
Locale-independent version of std::to_string.
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...
std::optional< bool > check_block_index
ValidationSignals * signals
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 _(const char *psz)
Translation function.
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.
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(const char *str)
bool SignalsOptInRBF(const CTransaction &tx)
Check whether the sequence numbers on this transaction are signaling opt-in to replace-by-fee,...
std::optional< std::string > PackageV3Checks(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 v3.
std::optional< std::pair< std::string, CTransactionRef > > SingleV3Checks(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 v3.
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(
static bool NotifyHeaderTip(ChainstateManager &chainman) LOCKS_EXCLUDED(cs_main)
static CSHA256 g_scriptExecutionCacheHasher
PackageMempoolAcceptResult ProcessNewPackage(Chainstate &active_chainstate, CTxMemPool &pool, const Package &package, bool test_accept, const std::optional< CFeeRate > &client_maxfeerate)
Validate (and maybe submit) a package to the mempool.
static void LimitMempoolSize(CTxMemPool &pool, CCoinsViewCache &coins_cache) EXCLUSIVE_LOCKS_REQUIRED(
static int64_t num_blocks_total
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
static SteadyClock::duration time_connect_total
std::condition_variable g_best_block_cv
MempoolAcceptResult AcceptToMemoryPool(Chainstate &active_chainstate, const CTransactionRef &tx, int64_t accept_time, bool bypass_limits, bool test_accept) EXCLUSIVE_LOCKS_REQUIRED(
Try to add a transaction to the mempool.
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)
static SynchronizationState GetSynchronizationState(bool init)
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 SteadyClock::duration time_post_connect
static SteadyClock::duration time_chainstate
bool InitScriptExecutionCache(size_t max_size_bytes)
Initializes the script-execution cache.
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 SteadyClock::duration time_forks
bool CheckInputScripts(const CTransaction &tx, TxValidationState &state, const CCoinsViewCache &inputs, unsigned int flags, bool cacheSigStore, bool cacheFullScriptStore, PrecomputedTransactionData &txdata, std::vector< CScriptCheck > *pvChecks=nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Check whether all of this transaction's input scripts succeed.
static bool CheckWitnessMalleation(const CBlock &block, bool expect_witness_commitment, BlockValidationState &state)
CheckWitnessMalleation performs checks for block malleation with regard to its witnesses.
static SteadyClock::duration time_verify
void UpdateCoins(const CTransaction &tx, CCoinsViewCache &inputs, CTxUndo &txundo, int nHeight)
static void AppendWarning(bilingual_str &res, const bilingual_str &warn)
Private helper function that concatenates warning messages.
static bool DeleteCoinsDBFromDisk(const fs::path db_path, bool is_snapshot) EXCLUSIVE_LOCKS_REQUIRED(
static bool CheckMerkleRoot(const CBlock &block, BlockValidationState &state)
static SteadyClock::duration time_check
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)
static SteadyClock::duration time_index
static bool CheckInputsFromMempoolAndCache(const CTransaction &tx, TxValidationState &state, const CCoinsViewCache &view, const CTxMemPool &pool, unsigned int flags, PrecomputedTransactionData &txdata, CCoinsViewCache &coins_tip) EXCLUSIVE_LOCKS_REQUIRED(cs_main
Checks to avoid mempool polluting consensus critical paths since cached signature and script validity...
static SteadyClock::duration time_connect
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)
static SteadyClock::duration time_undo
static CuckooCache::cache< uint256, SignatureCacheHasher > g_scriptExecutionCache
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 SteadyClock::duration time_total
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 SteadyClock::duration time_flush
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 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.
void SetfLargeWorkInvalidChainFound(bool flag)