mirror of
https://github.com/ElementsProject/elements.git
synced 2026-08-16 13:01:19 +02:00
Merge 3a7e0a210c into merged_master (Bitcoin PR bitcoin/bitcoin#24513)
This commit is contained in:
Byron Hambly
commit
b80b3aeff4
33 changed files with 154 additions and 154 deletions
|
|
@ -139,7 +139,7 @@ int64_t nMaxTipAge = DEFAULT_MAX_TIP_AGE;
|
|||
uint256 hashAssumeValid;
|
||||
arith_uint256 nMinimumChainWork;
|
||||
|
||||
const CBlockIndex* CChainState::FindForkInGlobalIndex(const CBlockLocator& locator) const
|
||||
const CBlockIndex* Chainstate::FindForkInGlobalIndex(const CBlockLocator& locator) const
|
||||
{
|
||||
AssertLockHeld(cs_main);
|
||||
|
||||
|
|
@ -287,7 +287,7 @@ static void LimitMempoolSize(CTxMemPool& pool, CCoinsViewCache& coins_cache)
|
|||
coins_cache.Uncache(removed);
|
||||
}
|
||||
|
||||
static bool IsCurrentForFeeEstimation(CChainState& active_chainstate) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
|
||||
static bool IsCurrentForFeeEstimation(Chainstate& active_chainstate) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
|
||||
{
|
||||
AssertLockHeld(cs_main);
|
||||
if (active_chainstate.IsInitialBlockDownload())
|
||||
|
|
@ -300,7 +300,7 @@ static bool IsCurrentForFeeEstimation(CChainState& active_chainstate) EXCLUSIVE_
|
|||
return true;
|
||||
}
|
||||
|
||||
void CChainState::MaybeUpdateMempoolForReorg(
|
||||
void Chainstate::MaybeUpdateMempoolForReorg(
|
||||
DisconnectedBlockTransactions& disconnectpool,
|
||||
bool fAddToMempool)
|
||||
{
|
||||
|
|
@ -442,7 +442,7 @@ namespace {
|
|||
class MemPoolAccept
|
||||
{
|
||||
public:
|
||||
explicit MemPoolAccept(CTxMemPool& mempool, CChainState& active_chainstate) : m_pool(mempool), m_view(&m_dummy), m_viewmempool(&active_chainstate.CoinsTip(), m_pool), m_active_chainstate(active_chainstate),
|
||||
explicit MemPoolAccept(CTxMemPool& mempool, Chainstate& active_chainstate) : m_pool(mempool), m_view(&m_dummy), m_viewmempool(&active_chainstate.CoinsTip(), m_pool), m_active_chainstate(active_chainstate),
|
||||
m_limit_ancestors(m_pool.m_limits.ancestor_count),
|
||||
m_limit_ancestor_size(m_pool.m_limits.ancestor_size_vbytes),
|
||||
m_limit_descendants(m_pool.m_limits.descendant_count),
|
||||
|
|
@ -678,7 +678,7 @@ private:
|
|||
CCoinsViewMemPool m_viewmempool;
|
||||
CCoinsView m_dummy;
|
||||
|
||||
CChainState& m_active_chainstate;
|
||||
Chainstate& m_active_chainstate;
|
||||
|
||||
// The package limits in effect at the time of invocation.
|
||||
const size_t m_limit_ancestors;
|
||||
|
|
@ -1507,7 +1507,7 @@ PackageMempoolAcceptResult MemPoolAccept::AcceptPackage(const Package& package,
|
|||
|
||||
} // anon namespace
|
||||
|
||||
MempoolAcceptResult AcceptToMemoryPool(CChainState& active_chainstate, const CTransactionRef& tx,
|
||||
MempoolAcceptResult AcceptToMemoryPool(Chainstate& active_chainstate, const CTransactionRef& tx,
|
||||
int64_t accept_time, bool bypass_limits, bool test_accept)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
|
||||
{
|
||||
|
|
@ -1534,7 +1534,7 @@ MempoolAcceptResult AcceptToMemoryPool(CChainState& active_chainstate, const CTr
|
|||
return result;
|
||||
}
|
||||
|
||||
PackageMempoolAcceptResult ProcessNewPackage(CChainState& active_chainstate, CTxMemPool& pool,
|
||||
PackageMempoolAcceptResult ProcessNewPackage(Chainstate& active_chainstate, CTxMemPool& pool,
|
||||
const Package& package, bool test_accept)
|
||||
{
|
||||
AssertLockHeld(cs_main);
|
||||
|
|
@ -1593,7 +1593,7 @@ void CoinsViews::InitCache()
|
|||
m_cacheview = std::make_unique<CCoinsViewCache>(&m_catcherview);
|
||||
}
|
||||
|
||||
CChainState::CChainState(
|
||||
Chainstate::Chainstate(
|
||||
CTxMemPool* mempool,
|
||||
BlockManager& blockman,
|
||||
ChainstateManager& chainman,
|
||||
|
|
@ -1604,7 +1604,7 @@ CChainState::CChainState(
|
|||
m_chainman(chainman),
|
||||
m_from_snapshot_blockhash(from_snapshot_blockhash) {}
|
||||
|
||||
void CChainState::InitCoinsDB(
|
||||
void Chainstate::InitCoinsDB(
|
||||
size_t cache_size_bytes,
|
||||
bool in_memory,
|
||||
bool should_wipe,
|
||||
|
|
@ -1618,7 +1618,7 @@ void CChainState::InitCoinsDB(
|
|||
leveldb_name, cache_size_bytes, in_memory, should_wipe);
|
||||
}
|
||||
|
||||
void CChainState::InitCoinsCache(size_t cache_size_bytes)
|
||||
void Chainstate::InitCoinsCache(size_t cache_size_bytes)
|
||||
{
|
||||
AssertLockHeld(::cs_main);
|
||||
assert(m_coins_views != nullptr);
|
||||
|
|
@ -1628,10 +1628,10 @@ void CChainState::InitCoinsCache(size_t cache_size_bytes)
|
|||
|
||||
// Note that though this is marked const, we may end up modifying `m_cached_finished_ibd`, which
|
||||
// is a performance-related implementation detail. This function must be marked
|
||||
// `const` so that `CValidationInterface` clients (which are given a `const CChainState*`)
|
||||
// `const` so that `CValidationInterface` clients (which are given a `const Chainstate*`)
|
||||
// can call it.
|
||||
//
|
||||
bool CChainState::IsInitialBlockDownload() const
|
||||
bool Chainstate::IsInitialBlockDownload() const
|
||||
{
|
||||
// Optimization: pre-test latch before taking the lock.
|
||||
if (m_cached_finished_ibd.load(std::memory_order_relaxed))
|
||||
|
|
@ -1673,7 +1673,7 @@ static void AlertNotify(const std::string& strMessage)
|
|||
#endif
|
||||
}
|
||||
|
||||
void CChainState::CheckForkWarningConditions()
|
||||
void Chainstate::CheckForkWarningConditions()
|
||||
{
|
||||
AssertLockHeld(cs_main);
|
||||
|
||||
|
|
@ -1692,7 +1692,7 @@ void CChainState::CheckForkWarningConditions()
|
|||
}
|
||||
|
||||
// Called both upon regular invalid block discovery *and* InvalidateBlock
|
||||
void CChainState::InvalidChainFound(CBlockIndex* pindexNew)
|
||||
void Chainstate::InvalidChainFound(CBlockIndex* pindexNew)
|
||||
{
|
||||
AssertLockHeld(cs_main);
|
||||
if (!m_chainman.m_best_invalid || pindexNew->nChainWork > m_chainman.m_best_invalid->nChainWork) {
|
||||
|
|
@ -1715,7 +1715,7 @@ void CChainState::InvalidChainFound(CBlockIndex* pindexNew)
|
|||
|
||||
// Same as InvalidChainFound, above, except not called directly from InvalidateBlock,
|
||||
// which does its own setBlockIndexCandidates management.
|
||||
void CChainState::InvalidBlockFound(CBlockIndex* pindex, const BlockValidationState& state)
|
||||
void Chainstate::InvalidBlockFound(CBlockIndex* pindex, const BlockValidationState& state)
|
||||
{
|
||||
AssertLockHeld(cs_main);
|
||||
if (state.GetResult() != BlockValidationResult::BLOCK_MUTATED) {
|
||||
|
|
@ -1965,7 +1965,7 @@ static bool TxOutDBEntryIsSame(const CTxOut& block_txout, const CTxOut& txdb_txo
|
|||
|
||||
/** Undo the effects of this block (with given index) on the UTXO set represented by coins.
|
||||
* When FAILED is returned, view is left in an indeterminate state. */
|
||||
DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view)
|
||||
DisconnectResult Chainstate::DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view)
|
||||
{
|
||||
AssertLockHeld(::cs_main);
|
||||
bool fClean = true;
|
||||
|
|
@ -2147,7 +2147,7 @@ bool CheckPeginRipeness(const CBlock& block, const std::vector<std::pair<CScript
|
|||
/** Apply the effects of this block (with given index) on the UTXO set represented by coins.
|
||||
* Validity checks that depend on the UTXO set are also done; ConnectBlock()
|
||||
* can fail if those validity checks fail (among other reasons). */
|
||||
bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state, CBlockIndex* pindex,
|
||||
bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state, CBlockIndex* pindex,
|
||||
CCoinsViewCache& view, std::set<std::pair<uint256, COutPoint>>* setPeginsSpent, bool fJustCheck)
|
||||
{
|
||||
AssertLockHeld(cs_main);
|
||||
|
|
@ -2518,7 +2518,7 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
|
|||
return true;
|
||||
}
|
||||
|
||||
CoinsCacheSizeState CChainState::GetCoinsCacheSizeState()
|
||||
CoinsCacheSizeState Chainstate::GetCoinsCacheSizeState()
|
||||
{
|
||||
AssertLockHeld(::cs_main);
|
||||
return this->GetCoinsCacheSizeState(
|
||||
|
|
@ -2526,7 +2526,7 @@ CoinsCacheSizeState CChainState::GetCoinsCacheSizeState()
|
|||
m_mempool ? m_mempool->m_max_size_bytes : 0);
|
||||
}
|
||||
|
||||
CoinsCacheSizeState CChainState::GetCoinsCacheSizeState(
|
||||
CoinsCacheSizeState Chainstate::GetCoinsCacheSizeState(
|
||||
size_t max_coins_cache_size_bytes,
|
||||
size_t max_mempool_size_bytes)
|
||||
{
|
||||
|
|
@ -2550,7 +2550,7 @@ CoinsCacheSizeState CChainState::GetCoinsCacheSizeState(
|
|||
return CoinsCacheSizeState::OK;
|
||||
}
|
||||
|
||||
bool CChainState::FlushStateToDisk(
|
||||
bool Chainstate::FlushStateToDisk(
|
||||
BlockValidationState &state,
|
||||
FlushStateMode mode,
|
||||
int nManualPruneHeight)
|
||||
|
|
@ -2735,7 +2735,7 @@ bool CChainState::FlushStateToDisk(
|
|||
return true;
|
||||
}
|
||||
|
||||
void CChainState::ForceFlushStateToDisk()
|
||||
void Chainstate::ForceFlushStateToDisk()
|
||||
{
|
||||
BlockValidationState state;
|
||||
if (!this->FlushStateToDisk(state, FlushStateMode::ALWAYS)) {
|
||||
|
|
@ -2743,7 +2743,7 @@ void CChainState::ForceFlushStateToDisk()
|
|||
}
|
||||
}
|
||||
|
||||
void CChainState::PruneAndFlush()
|
||||
void Chainstate::PruneAndFlush()
|
||||
{
|
||||
BlockValidationState state;
|
||||
m_blockman.m_check_for_pruning = true;
|
||||
|
|
@ -2802,7 +2802,7 @@ void ForceUntrimHeader(const CBlockIndex *pindex_) EXCLUSIVE_LOCKS_REQUIRED(::cs
|
|||
pindex->untrim();
|
||||
}
|
||||
|
||||
void CChainState::UpdateTip(const CBlockIndex* pindexNew)
|
||||
void Chainstate::UpdateTip(const CBlockIndex* pindexNew)
|
||||
{
|
||||
AssertLockHeld(::cs_main);
|
||||
const auto& coins_tip = this->CoinsTip();
|
||||
|
|
@ -2872,7 +2872,7 @@ void CChainState::UpdateTip(const CBlockIndex* pindexNew)
|
|||
* disconnectpool (note that the caller is responsible for mempool consistency
|
||||
* in any case).
|
||||
*/
|
||||
bool CChainState::DisconnectTip(BlockValidationState& state, DisconnectedBlockTransactions* disconnectpool)
|
||||
bool Chainstate::DisconnectTip(BlockValidationState& state, DisconnectedBlockTransactions* disconnectpool)
|
||||
{
|
||||
AssertLockHeld(cs_main);
|
||||
if (m_mempool) AssertLockHeld(m_mempool->cs);
|
||||
|
|
@ -2988,7 +2988,7 @@ public:
|
|||
*
|
||||
* The block is added to connectTrace if connection succeeds.
|
||||
*/
|
||||
bool CChainState::ConnectTip(BlockValidationState& state, CBlockIndex* pindexNew, const std::shared_ptr<const CBlock>& pblock, ConnectTrace& connectTrace, DisconnectedBlockTransactions& disconnectpool, bool& fStall)
|
||||
bool Chainstate::ConnectTip(BlockValidationState& state, CBlockIndex* pindexNew, const std::shared_ptr<const CBlock>& pblock, ConnectTrace& connectTrace, DisconnectedBlockTransactions& disconnectpool, bool& fStall)
|
||||
{
|
||||
AssertLockHeld(cs_main);
|
||||
if (m_mempool) AssertLockHeld(m_mempool->cs);
|
||||
|
|
@ -3072,7 +3072,7 @@ bool CChainState::ConnectTip(BlockValidationState& state, CBlockIndex* pindexNew
|
|||
* Return the tip of the chain with the most work in it, that isn't
|
||||
* known to be invalid (it's however far from certain to be valid).
|
||||
*/
|
||||
CBlockIndex* CChainState::FindMostWorkChain()
|
||||
CBlockIndex* Chainstate::FindMostWorkChain()
|
||||
{
|
||||
AssertLockHeld(::cs_main);
|
||||
do {
|
||||
|
|
@ -3131,7 +3131,7 @@ CBlockIndex* CChainState::FindMostWorkChain()
|
|||
}
|
||||
|
||||
/** Delete all entries in setBlockIndexCandidates that are worse than the current tip. */
|
||||
void CChainState::PruneBlockIndexCandidates() {
|
||||
void Chainstate::PruneBlockIndexCandidates() {
|
||||
// Note that we can't delete the current block itself, as we may need to return to it later in case a
|
||||
// reorganization to a better block fails.
|
||||
std::set<CBlockIndex*, CBlockIndexWorkComparator>::iterator it = setBlockIndexCandidates.begin();
|
||||
|
|
@ -3148,7 +3148,7 @@ void CChainState::PruneBlockIndexCandidates() {
|
|||
*
|
||||
* @returns true unless a system error occurred
|
||||
*/
|
||||
bool CChainState::ActivateBestChainStep(BlockValidationState& state, CBlockIndex* pindexMostWork, const std::shared_ptr<const CBlock>& pblock, bool& fInvalidFound, ConnectTrace& connectTrace, bool& fStall)
|
||||
bool Chainstate::ActivateBestChainStep(BlockValidationState& state, CBlockIndex* pindexMostWork, const std::shared_ptr<const CBlock>& pblock, bool& fInvalidFound, ConnectTrace& connectTrace, bool& fStall)
|
||||
{
|
||||
AssertLockHeld(cs_main);
|
||||
if (m_mempool) AssertLockHeld(m_mempool->cs);
|
||||
|
|
@ -3246,7 +3246,7 @@ static SynchronizationState GetSynchronizationState(bool init)
|
|||
return SynchronizationState::INIT_DOWNLOAD;
|
||||
}
|
||||
|
||||
static bool NotifyHeaderTip(CChainState& chainstate) LOCKS_EXCLUDED(cs_main) {
|
||||
static bool NotifyHeaderTip(Chainstate& chainstate) LOCKS_EXCLUDED(cs_main) {
|
||||
bool fNotify = false;
|
||||
bool fInitialBlockDownload = false;
|
||||
static CBlockIndex* pindexHeaderOld = nullptr;
|
||||
|
|
@ -3276,7 +3276,7 @@ static void LimitValidationInterfaceQueue() LOCKS_EXCLUDED(cs_main) {
|
|||
}
|
||||
}
|
||||
|
||||
bool CChainState::ActivateBestChain(BlockValidationState& state, std::shared_ptr<const CBlock> pblock)
|
||||
bool Chainstate::ActivateBestChain(BlockValidationState& state, std::shared_ptr<const CBlock> pblock)
|
||||
{
|
||||
AssertLockNotHeld(m_chainstate_mutex);
|
||||
|
||||
|
|
@ -3390,7 +3390,7 @@ bool CChainState::ActivateBestChain(BlockValidationState& state, std::shared_ptr
|
|||
return true;
|
||||
}
|
||||
|
||||
bool CChainState::PreciousBlock(BlockValidationState& state, CBlockIndex* pindex)
|
||||
bool Chainstate::PreciousBlock(BlockValidationState& state, CBlockIndex* pindex)
|
||||
{
|
||||
AssertLockNotHeld(m_chainstate_mutex);
|
||||
AssertLockNotHeld(::cs_main);
|
||||
|
|
@ -3421,7 +3421,7 @@ bool CChainState::PreciousBlock(BlockValidationState& state, CBlockIndex* pindex
|
|||
return ActivateBestChain(state, std::shared_ptr<const CBlock>());
|
||||
}
|
||||
|
||||
bool CChainState::InvalidateBlock(BlockValidationState& state, CBlockIndex* pindex)
|
||||
bool Chainstate::InvalidateBlock(BlockValidationState& state, CBlockIndex* pindex)
|
||||
{
|
||||
AssertLockNotHeld(m_chainstate_mutex);
|
||||
AssertLockNotHeld(::cs_main);
|
||||
|
|
@ -3564,7 +3564,7 @@ bool CChainState::InvalidateBlock(BlockValidationState& state, CBlockIndex* pind
|
|||
return true;
|
||||
}
|
||||
|
||||
void CChainState::ResetBlockFailureFlags(CBlockIndex *pindex) {
|
||||
void Chainstate::ResetBlockFailureFlags(CBlockIndex *pindex) {
|
||||
AssertLockHeld(cs_main);
|
||||
|
||||
int nHeight = pindex->nHeight;
|
||||
|
|
@ -3597,7 +3597,7 @@ void CChainState::ResetBlockFailureFlags(CBlockIndex *pindex) {
|
|||
}
|
||||
|
||||
/** Mark a block as having its data received and checked (up to BLOCK_VALID_TRANSACTIONS). */
|
||||
void CChainState::ReceivedBlockTransactions(const CBlock& block, CBlockIndex* pindexNew, const FlatFilePos& pos)
|
||||
void Chainstate::ReceivedBlockTransactions(const CBlock& block, CBlockIndex* pindexNew, const FlatFilePos& pos)
|
||||
{
|
||||
AssertLockHeld(cs_main);
|
||||
pindexNew->nTx = block.vtx.size();
|
||||
|
|
@ -4205,7 +4205,7 @@ void ChainstateManager::ReportHeadersPresync(const arith_uint256& work, int64_t
|
|||
}
|
||||
|
||||
/** Store block on disk. If dbp is non-nullptr, the file is known to already reside on disk */
|
||||
bool CChainState::AcceptBlock(const std::shared_ptr<const CBlock>& pblock, BlockValidationState& state, CBlockIndex** ppindex, bool fRequested, const FlatFilePos* dbp, bool* fNewBlock, bool min_pow_checked)
|
||||
bool Chainstate::AcceptBlock(const std::shared_ptr<const CBlock>& pblock, BlockValidationState& state, CBlockIndex** ppindex, bool fRequested, const FlatFilePos* dbp, bool* fNewBlock, bool min_pow_checked)
|
||||
{
|
||||
const CBlock& block = *pblock;
|
||||
|
||||
|
|
@ -4331,7 +4331,7 @@ bool ChainstateManager::ProcessNewBlock(const std::shared_ptr<const CBlock>& blo
|
|||
MempoolAcceptResult ChainstateManager::ProcessTransaction(const CTransactionRef& tx, bool test_accept)
|
||||
{
|
||||
AssertLockHeld(cs_main);
|
||||
CChainState& active_chainstate = ActiveChainstate();
|
||||
Chainstate& active_chainstate = ActiveChainstate();
|
||||
if (!active_chainstate.GetMempool()) {
|
||||
TxValidationState state;
|
||||
state.Invalid(TxValidationResult::TX_NO_MEMPOOL, "no-mempool");
|
||||
|
|
@ -4344,7 +4344,7 @@ MempoolAcceptResult ChainstateManager::ProcessTransaction(const CTransactionRef&
|
|||
|
||||
bool TestBlockValidity(BlockValidationState& state,
|
||||
const CChainParams& chainparams,
|
||||
CChainState& chainstate,
|
||||
Chainstate& chainstate,
|
||||
const CBlock& block,
|
||||
CBlockIndex* pindexPrev,
|
||||
const std::function<NodeClock::time_point()>& adjusted_time_callback,
|
||||
|
|
@ -4376,7 +4376,7 @@ bool TestBlockValidity(BlockValidationState& state,
|
|||
}
|
||||
|
||||
/* This function is called from the RPC code for pruneblockchain */
|
||||
void PruneBlockFilesManual(CChainState& active_chainstate, int nManualPruneHeight)
|
||||
void PruneBlockFilesManual(Chainstate& active_chainstate, int nManualPruneHeight)
|
||||
{
|
||||
BlockValidationState state;
|
||||
if (!active_chainstate.FlushStateToDisk(
|
||||
|
|
@ -4385,14 +4385,14 @@ void PruneBlockFilesManual(CChainState& active_chainstate, int nManualPruneHeigh
|
|||
}
|
||||
}
|
||||
|
||||
void CChainState::LoadMempool(const fs::path& load_path, FopenFn mockable_fopen_function)
|
||||
void Chainstate::LoadMempool(const fs::path& load_path, FopenFn mockable_fopen_function)
|
||||
{
|
||||
if (!m_mempool) return;
|
||||
::LoadMempool(*m_mempool, load_path, *this, mockable_fopen_function);
|
||||
m_mempool->SetLoadTried(!ShutdownRequested());
|
||||
}
|
||||
|
||||
bool CChainState::LoadChainTip()
|
||||
bool Chainstate::LoadChainTip()
|
||||
{
|
||||
AssertLockHeld(cs_main);
|
||||
const CCoinsViewCache& coins_cache = CoinsTip();
|
||||
|
|
@ -4431,7 +4431,7 @@ CVerifyDB::~CVerifyDB()
|
|||
}
|
||||
|
||||
bool CVerifyDB::VerifyDB(
|
||||
CChainState& chainstate,
|
||||
Chainstate& chainstate,
|
||||
const Consensus::Params& consensus_params,
|
||||
CCoinsView& coinsview,
|
||||
int nCheckLevel, int nCheckDepth)
|
||||
|
|
@ -4548,7 +4548,7 @@ bool CVerifyDB::VerifyDB(
|
|||
}
|
||||
|
||||
/** Apply the effects of a block on the utxo cache, ignoring that it may already have been applied. */
|
||||
bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& inputs)
|
||||
bool Chainstate::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& inputs)
|
||||
{
|
||||
AssertLockHeld(cs_main);
|
||||
// TODO: merge with ConnectBlock
|
||||
|
|
@ -4569,7 +4569,7 @@ bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& i
|
|||
return true;
|
||||
}
|
||||
|
||||
bool CChainState::ReplayBlocks()
|
||||
bool Chainstate::ReplayBlocks()
|
||||
{
|
||||
LOCK(cs_main);
|
||||
|
||||
|
|
@ -4637,7 +4637,7 @@ bool CChainState::ReplayBlocks()
|
|||
return true;
|
||||
}
|
||||
|
||||
bool CChainState::NeedsRedownload() const
|
||||
bool Chainstate::NeedsRedownload() const
|
||||
{
|
||||
AssertLockHeld(cs_main);
|
||||
|
||||
|
|
@ -4655,7 +4655,7 @@ bool CChainState::NeedsRedownload() const
|
|||
return false;
|
||||
}
|
||||
|
||||
void CChainState::UnloadBlockIndex()
|
||||
void Chainstate::UnloadBlockIndex()
|
||||
{
|
||||
AssertLockHeld(::cs_main);
|
||||
nBlockSequenceId = 1;
|
||||
|
|
@ -4724,7 +4724,7 @@ bool ChainstateManager::LoadBlockIndex()
|
|||
// detecting "holistically" whether the block index under consideration
|
||||
// relied on an assumed-valid ancestor, but this proved to be too slow to
|
||||
// be practical.
|
||||
for (CChainState* chainstate : GetAll()) {
|
||||
for (Chainstate* chainstate : GetAll()) {
|
||||
if (chainstate->reliesOnAssumedValid() ||
|
||||
pindex->nHeight < first_assumed_valid_height) {
|
||||
chainstate->setBlockIndexCandidates.insert(pindex);
|
||||
|
|
@ -4753,7 +4753,7 @@ bool ChainstateManager::LoadBlockIndex()
|
|||
return true;
|
||||
}
|
||||
|
||||
bool CChainState::LoadGenesisBlock()
|
||||
bool Chainstate::LoadGenesisBlock()
|
||||
{
|
||||
LOCK(cs_main);
|
||||
|
||||
|
|
@ -4779,7 +4779,7 @@ bool CChainState::LoadGenesisBlock()
|
|||
return true;
|
||||
}
|
||||
|
||||
void CChainState::LoadExternalBlockFile(
|
||||
void Chainstate::LoadExternalBlockFile(
|
||||
FILE* fileIn,
|
||||
FlatFilePos* dbp,
|
||||
std::multimap<uint256, FlatFilePos>* blocks_with_unknown_parent)
|
||||
|
|
@ -4906,7 +4906,7 @@ void CChainState::LoadExternalBlockFile(
|
|||
LogPrintf("Loaded %i blocks from external file in %dms\n", nLoaded, GetTimeMillis() - nStart);
|
||||
}
|
||||
|
||||
void CChainState::CheckBlockIndex()
|
||||
void Chainstate::CheckBlockIndex()
|
||||
{
|
||||
if (!fCheckBlockIndex) {
|
||||
return;
|
||||
|
|
@ -5128,7 +5128,7 @@ void CChainState::CheckBlockIndex()
|
|||
assert(nNodes == forward.size());
|
||||
}
|
||||
|
||||
std::string CChainState::ToString()
|
||||
std::string Chainstate::ToString()
|
||||
{
|
||||
AssertLockHeld(::cs_main);
|
||||
CBlockIndex* tip = m_chain.Tip();
|
||||
|
|
@ -5137,7 +5137,7 @@ std::string CChainState::ToString()
|
|||
tip ? tip->nHeight : -1, tip ? tip->GetBlockHash().ToString() : "null");
|
||||
}
|
||||
|
||||
bool CChainState::ResizeCoinsCaches(size_t coinstip_size, size_t coinsdb_size)
|
||||
bool Chainstate::ResizeCoinsCaches(size_t coinstip_size, size_t coinsdb_size)
|
||||
{
|
||||
AssertLockHeld(::cs_main);
|
||||
if (coinstip_size == m_coinstip_cache_size_bytes &&
|
||||
|
|
@ -5198,10 +5198,10 @@ std::optional<uint256> ChainstateManager::SnapshotBlockhash() const
|
|||
return std::nullopt;
|
||||
}
|
||||
|
||||
std::vector<CChainState*> ChainstateManager::GetAll()
|
||||
std::vector<Chainstate*> ChainstateManager::GetAll()
|
||||
{
|
||||
LOCK(::cs_main);
|
||||
std::vector<CChainState*> out;
|
||||
std::vector<Chainstate*> out;
|
||||
|
||||
if (!IsSnapshotValidated() && m_ibd_chainstate) {
|
||||
out.push_back(m_ibd_chainstate.get());
|
||||
|
|
@ -5214,18 +5214,18 @@ std::vector<CChainState*> ChainstateManager::GetAll()
|
|||
return out;
|
||||
}
|
||||
|
||||
CChainState& ChainstateManager::InitializeChainstate(
|
||||
Chainstate& ChainstateManager::InitializeChainstate(
|
||||
CTxMemPool* mempool, const std::optional<uint256>& snapshot_blockhash)
|
||||
{
|
||||
AssertLockHeld(::cs_main);
|
||||
bool is_snapshot = snapshot_blockhash.has_value();
|
||||
std::unique_ptr<CChainState>& to_modify =
|
||||
std::unique_ptr<Chainstate>& to_modify =
|
||||
is_snapshot ? m_snapshot_chainstate : m_ibd_chainstate;
|
||||
|
||||
if (to_modify) {
|
||||
throw std::logic_error("should not be overwriting a chainstate");
|
||||
}
|
||||
to_modify.reset(new CChainState(mempool, m_blockman, *this, snapshot_blockhash));
|
||||
to_modify.reset(new Chainstate(mempool, m_blockman, *this, snapshot_blockhash));
|
||||
|
||||
// Snapshot chainstates and initial IBD chaintates always become active.
|
||||
if (is_snapshot || (!is_snapshot && !m_active_chainstate)) {
|
||||
|
|
@ -5295,7 +5295,7 @@ bool ChainstateManager::ActivateSnapshot(
|
|||
}
|
||||
|
||||
auto snapshot_chainstate = WITH_LOCK(::cs_main,
|
||||
return std::make_unique<CChainState>(
|
||||
return std::make_unique<Chainstate>(
|
||||
/*mempool=*/nullptr, m_blockman, *this, base_blockhash));
|
||||
|
||||
{
|
||||
|
|
@ -5345,7 +5345,7 @@ static void FlushSnapshotToDisk(CCoinsViewCache& coins_cache, bool snapshot_load
|
|||
}
|
||||
|
||||
bool ChainstateManager::PopulateAndValidateSnapshot(
|
||||
CChainState& snapshot_chainstate,
|
||||
Chainstate& snapshot_chainstate,
|
||||
AutoFile& coins_file,
|
||||
const SnapshotMetadata& metadata)
|
||||
{
|
||||
|
|
@ -5439,7 +5439,7 @@ bool ChainstateManager::PopulateAndValidateSnapshot(
|
|||
|
||||
// Important that we set this. This and the coins_cache accesses above are
|
||||
// sort of a layer violation, but either we reach into the innards of
|
||||
// CCoinsViewCache here or we have to invert some of the CChainState to
|
||||
// CCoinsViewCache here or we have to invert some of the Chainstate to
|
||||
// embed them in a snapshot-activation-specific CCoinsViewCache bulk load
|
||||
// method.
|
||||
coins_cache.SetBestBlock(base_blockhash);
|
||||
|
|
@ -5518,7 +5518,7 @@ bool ChainstateManager::PopulateAndValidateSnapshot(
|
|||
index->nStatus |= BLOCK_ASSUMED_VALID;
|
||||
}
|
||||
|
||||
// Fake BLOCK_OPT_WITNESS so that CChainState::NeedsRedownload()
|
||||
// Fake BLOCK_OPT_WITNESS so that Chainstate::NeedsRedownload()
|
||||
// won't ask to rewind the entire assumed-valid chain on startup.
|
||||
if (DeploymentActiveAt(*index, *this, Consensus::DEPLOYMENT_SEGWIT)) {
|
||||
index->nStatus |= BLOCK_OPT_WITNESS;
|
||||
|
|
@ -5541,7 +5541,7 @@ bool ChainstateManager::PopulateAndValidateSnapshot(
|
|||
return true;
|
||||
}
|
||||
|
||||
CChainState& ChainstateManager::ActiveChainstate() const
|
||||
Chainstate& ChainstateManager::ActiveChainstate() const
|
||||
{
|
||||
LOCK(::cs_main);
|
||||
assert(m_active_chainstate);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue