Where validation becomes chain state

5251                if (c->m_chain.Genesis() != nullptr) {
5252                    assert(pindex == c->m_chain.Genesis()); // The chain's genesis block must be this block.
5253                }
5254            }
5255        }
5256        // nSequenceId can't be set higher than SEQ_ID_INIT_FROM_DISK{1} for blocks that aren't linked
5257        // (negative is used for preciousblock, SEQ_ID_BEST_CHAIN_FROM_DISK{0} for active chain when loaded from disk)
5258        if (!pindex->HaveNumChainTxs()) assert(pindex->nSequenceId <= SEQ_ID_INIT_FROM_DISK);
5259        // VALID_TRANSACTIONS is equivalent to nTx > 0 for all nodes (whether or not pruning has occurred).
5260        // HAVE_DATA is only equivalent to nTx > 0 (or VALID_TRANSACTIONS) if no pruning has occurred.
5261        if (!m_blockman.m_have_pruned) {
5262            // If we've never pruned, then HAVE_DATA should be equivalent to nTx > 0
5263            assert(!(pindex->nStatus & BLOCK_HAVE_DATA) == (pindex->nTx == 0));
5264            assert(pindexFirstMissing == pindexFirstNeverProcessed);
5265        } else {
5266            // If we have pruned, then we can only say that HAVE_DATA implies nTx > 0
5267            if (pindex->nStatus & BLOCK_HAVE_DATA) assert(pindex->nTx > 0);
5268        }
5269        if (pindex->nStatus & BLOCK_HAVE_UNDO) assert(pindex->nStatus & BLOCK_HAVE_DATA);
5270        if (snap_base && snap_base->GetAncestor(pindex->nHeight) == pindex) {
5271            // Assumed-valid blocks should connect to the main chain.
5272            assert((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_TREE);
5273        }
5274        // There should only be an nTx value if we have
5275        // actually seen a block's transactions.
5276        assert(((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_TRANSACTIONS) == (pindex->nTx > 0)); // This is pruning-independent.
5277        // All parents having had data (at some point) is equivalent to all parents being VALID_TRANSACTIONS, which is equivalent to HaveNumChainTxs().
5278        // HaveNumChainTxs will also be set in the assumeutxo snapshot block from snapshot metadata.
5279        assert((pindexFirstNeverProcessed == nullptr || pindex == snap_base) == pindex->HaveNumChainTxs());
5280        assert((pindexFirstNotTransactionsValid == nullptr || pindex == snap_base) == pindex->HaveNumChainTxs());
5281        assert(pindex->nHeight == nHeight); // nHeight must be consistent.
5282        assert(pindex->pprev == nullptr || pindex->nChainWork >= pindex->pprev->nChainWork); // For every block except the genesis block, the chainwork must be larger than the parent's.
5283        assert(nHeight < 2 || (pindex->pskip && (pindex->pskip->nHeight < nHeight))); // The pskip pointer must point back for all but the first 2 blocks.
5284        assert(pindexFirstNotTreeValid == nullptr); // All m_blockman.m_block_index entries must at least be TREE valid
5285        if ((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_TREE) assert(pindexFirstNotTreeValid == nullptr); // TREE valid implies all parents are TREE valid
5286        if ((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_CHAIN) assert(pindexFirstNotChainValid == nullptr); // CHAIN valid implies all parents are CHAIN valid
5287        if ((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_SCRIPTS) assert(pindexFirstNotScriptsValid == nullptr); // SCRIPTS valid implies all parents are SCRIPTS valid
5288        if (pindexFirstInvalid == nullptr) {
5289            // Checks for not-invalid blocks.
5290            assert((pindex->nStatus & BLOCK_FAILED_VALID) == 0); // The failed flag cannot be set for blocks without invalid parents.
5291        } else {
5292            assert(pindex->nStatus & BLOCK_FAILED_VALID); // Invalid blocks and their descendants must be marked as invalid
5293        }
5294        // Make sure m_chain_tx_count sum is correctly computed.
5295        if (!pindex->pprev) {
5296            // If no previous block, nTx and m_chain_tx_count must be the same.
5297            assert(pindex->m_chain_tx_count == pindex->nTx);
5298        } else if (pindex->pprev->m_chain_tx_count > 0 && pindex->nTx > 0) {
5299            // If previous m_chain_tx_count is set and number of transactions in block is known, sum must be set.
5300            assert(pindex->m_chain_tx_count == pindex->nTx + pindex->pprev->m_chain_tx_count);
5301        } else {
5302            // Otherwise m_chain_tx_count should only be set if this is a snapshot
5303            // block, and must be set if it is.
5304            assert((pindex->m_chain_tx_count != 0) == (pindex == snap_base));
5305        }
5306        // There should be no block with more work than m_best_header, unless it's known to be invalid
5307        assert((pindex->nStatus & BLOCK_FAILED_VALID) || pindex->nChainWork <= m_best_header->nChainWork);
5308
5309        // Chainstate-specific checks on setBlockIndexCandidates
5310        for (const auto& c : m_chainstates) {
5311            if (c->m_chain.Tip() == nullptr) continue;
5312            // Two main factors determine whether pindex is a candidate in
5313            // setBlockIndexCandidates:
5314            //
5315            // - If pindex has less work than the chain tip, it should not be a
5316            //   candidate, and this will be asserted below. Otherwise it is a
5317            //   potential candidate.
5318            //
5319            // - If pindex or one of its parent blocks back to the genesis block
5320            //   or an assumeutxo snapshot never downloaded transactions
5321            //   (pindexFirstNeverProcessed is non-null), it should not be a
5322            //   candidate, and this will be asserted below. The only exception
5323            //   is if pindex itself is an assumeutxo snapshot block. Then it is
5324            //   also a potential candidate.
5325            if (!CBlockIndexWorkComparator()(pindex, c->m_chain.Tip()) && (pindexFirstNeverProcessed == nullptr || pindex == snap_base)) {
5326                // If pindex was detected as invalid (pindexFirstInvalid is
5327                // non-null), it is not required to be in
5328                // setBlockIndexCandidates.
5329                if (pindexFirstInvalid == nullptr) {
5330                    // If pindex and all its parents back to the genesis block
5331                    // or an assumeutxo snapshot block downloaded transactions,
5332                    // and the transactions were not pruned (pindexFirstMissing
5333                    // is null), it is a potential candidate. The check
5334                    // excludes pruned blocks, because if any blocks were
5335                    // pruned between pindex and the current chain tip, pindex will
5336                    // only temporarily be added to setBlockIndexCandidates,
5337                    // before being moved to m_blocks_unlinked. This check
5338                    // could be improved to verify that if all blocks between
5339                    // the chain tip and pindex have data, pindex must be a
5340                    // candidate.
5341                    //
5342                    // If pindex is the chain tip, it also is a potential
5343                    // candidate.
5344                    //
5345                    // If the chainstate was loaded from a snapshot and pindex
5346                    // is the base of the snapshot, pindex is also a potential
5347                    // candidate.
5348                    if (pindexFirstMissing == nullptr || pindex == c->m_chain.Tip() || pindex == c->SnapshotBase()) {
5349                        // If this chainstate is not a historical chainstate
5350                        // targeting a specific block, pindex must be in
5351                        // setBlockIndexCandidates. Otherwise, pindex only
5352                        // needs to be added if it is an ancestor of the target
5353                        // block.
5354                        if (!c->TargetBlock() || c->TargetBlock()->GetAncestor(pindex->nHeight) == pindex) {
5355                            assert(c->setBlockIndexCandidates.contains(pindex));
5356                        }
5357                    }
5358                    // If some parent is missing, then it could be that this block was in
5359                    // setBlockIndexCandidates but had to be removed because of the missing data.
5360                    // In this case it must be in m_blocks_unlinked -- see test below.
5361                }
5362            } else { // If this block sorts worse than the current tip or some ancestor's block has never been seen, it cannot be in setBlockIndexCandidates.
5363                assert(!c->setBlockIndexCandidates.contains(pindex));
5364            }
5365        }
5366        // Check whether this block is in m_blocks_unlinked.
5367        auto rangeUnlinked{m_blockman.m_blocks_unlinked.equal_range(pindex->pprev)};
5368        bool foundInUnlinked = false;
5369        for (auto it = rangeUnlinked.first; it != rangeUnlinked.second; ++it) {
5370            assert(it->first == pindex->pprev);
5371            if (it->second == pindex) {
5372                assert(!foundInUnlinked); // No duplicates in m_blocks_unlinked
5373                foundInUnlinked = true;
5374            }
5375        }
5376        if (pindex->pprev && (pindex->nStatus & BLOCK_HAVE_DATA) && pindexFirstNeverProcessed != nullptr && pindexFirstInvalid == nullptr) {
5377            // If this block has block data available, some parent was never received, and has no invalid parents, it must be in m_blocks_unlinked.
5378            assert(foundInUnlinked);
5379        }
5380        if (!(pindex->nStatus & BLOCK_HAVE_DATA)) assert(!foundInUnlinked); // Can't be in m_blocks_unlinked if we don't HAVE_DATA
5381        if (pindexFirstMissing == nullptr) assert(!foundInUnlinked); // We aren't missing data for any parent -- cannot be in m_blocks_unlinked.
5382        if (pindex->pprev && (pindex->nStatus & BLOCK_HAVE_DATA) && pindexFirstNeverProcessed == nullptr && pindexFirstMissing != nullptr) {
5383            // We HAVE_DATA for this block, have received data for all parents at some point, but we're currently missing data for some parent.
5384            assert(m_blockman.m_have_pruned);
5385            // This block may have entered m_blocks_unlinked if:
5386            //  - it has a descendant that at some point had more work than the
5387            //    tip, and
5388            //  - we tried switching to that descendant but were missing
5389            //    data for some intermediate block between m_chain and the
5390            //    tip.
5391            // So if this block is itself better than any m_chain.Tip() and it wasn't in
5392            // setBlockIndexCandidates, then it must be in m_blocks_unlinked.
5393            for (const auto& c : m_chainstates) {
5394                if (!CBlockIndexWorkComparator()(pindex, c->m_chain.Tip()) && !c->setBlockIndexCandidates.contains(pindex)) {
5395                    if (pindexFirstInvalid == nullptr) {
5396                        if (!c->TargetBlock() || c->TargetBlock()->GetAncestor(pindex->nHeight) == pindex) {
5397                            assert(foundInUnlinked);
5398                        }
5399                    }
5400                }
5401            }
5402        }
5403        // assert(pindex->GetBlockHash() == pindex->GetBlockHeader().GetHash()); // Perhaps too slow
5404        // End: actual consistency checks.
5405
5406
5407        // Try descending into the first subnode. Always process forks first and the best header chain after.
5408        snap_update_firsts();
5409        auto range{forward.equal_range(pindex)};
5410        if (range.first != range.second) {
5411            // A subnode not part of the best header chain was found.
5412            pindex = range.first->second;
5413            nHeight++;
5414            continue;
5415        } else if (best_hdr_chain.Contains(*pindex)) {
5416            // Descend further into best header chain.
5417            nHeight++;
5418            pindex = best_hdr_chain[nHeight];
5419            if (!pindex) break; // we are finished, since the best header chain is always processed last
5420            continue;
5421        }
5422        // This is a leaf node.
5423        // Move upwards until we reach a node of which we have not yet visited the last child.
5424        while (pindex) {
5425            // We are going to either move to a parent or a sibling of pindex.
5426            snap_update_firsts();
5427            // If pindex was the first with a certain property, unset the corresponding variable.
5428            if (pindex == pindexFirstInvalid) pindexFirstInvalid = nullptr;
5429            if (pindex == pindexFirstMissing) pindexFirstMissing = nullptr;
5430            if (pindex == pindexFirstNeverProcessed) pindexFirstNeverProcessed = nullptr;
5431            if (pindex == pindexFirstNotTreeValid) pindexFirstNotTreeValid = nullptr;
5432            if (pindex == pindexFirstNotTransactionsValid) pindexFirstNotTransactionsValid = nullptr;
5433            if (pindex == pindexFirstNotChainValid) pindexFirstNotChainValid = nullptr;
5434            if (pindex == pindexFirstNotScriptsValid) pindexFirstNotScriptsValid = nullptr;
5435            // Find our parent.
5436            CBlockIndex* pindexPar = pindex->pprev;
5437            // Find which child we just visited.
5438            auto rangePar{forward.equal_range(pindexPar)};
5439            while (rangePar.first->second != pindex) {
5440                assert(rangePar.first != rangePar.second); // Our parent must have at least the node we're coming from as child.
5441                rangePar.first++;
5442            }
5443            // Proceed to the next one.
5444            rangePar.first++;
5445            if (rangePar.first != rangePar.second) {
5446                // Move to a sibling not part of the best header chain.
5447                pindex = rangePar.first->second;
5448                break;
5449            } else if (pindexPar == best_hdr_chain[nHeight - 1]) {
5450                // Move to pindex's sibling on the best-chain, if it has one.
5451                pindex = best_hdr_chain[nHeight];
5452                // There will not be a next block if (and only if) parent block is the best header.
5453                assert((pindex == nullptr) == (pindexPar == best_hdr_chain.Tip()));
5454                break;
5455            } else {
5456                // Move up further.
5457                pindex = pindexPar;
5458                nHeight--;
5459                continue;
5460            }
5461        }
5462    }
5463
5464    // Check that we actually traversed the entire block index.
5465    assert(nNodes == forward.size() + best_hdr_chain.Height() + 1);
5466}
5467
5468std::string Chainstate::ToString()
5469{
5470    AssertLockHeld(::cs_main);
5471    CBlockIndex* tip = m_chain.Tip();
5472    return strprintf("Chainstate [%s] @ height %d (%s)",
5473                     m_from_snapshot_blockhash ? "snapshot" : "ibd",
5474                     tip ? tip->nHeight : -1, tip ? tip->GetBlockHash().ToString() : "null");
5475}
5476
5477bool Chainstate::ResizeCoinsCaches(size_t coinstip_size, size_t coinsdb_size)
5478{
5479    AssertLockHeld(::cs_main);
5480    if (coinstip_size == m_coinstip_cache_size_bytes &&
5481            coinsdb_size == m_coinsdb_cache_size_bytes) {
5482        // Cache sizes are unchanged, no need to continue.
5483        return true;
5484    }
5485    size_t old_coinstip_size = m_coinstip_cache_size_bytes;
5486    m_coinstip_cache_size_bytes = coinstip_size;
5487    m_coinsdb_cache_size_bytes = coinsdb_size;
5488    CoinsDB().ResizeCache(coinsdb_size);
5489
5490    LogInfo("[%s] resized coinsdb cache to %.1f MiB",
5491        this->ToString(), coinsdb_size / double(1_MiB));
5492    LogInfo("[%s] resized coinstip cache to %.1f MiB",
5493        this->ToString(), coinstip_size / double(1_MiB));
5494
5495    BlockValidationState state;
5496    bool ret;
5497
5498    if (coinstip_size > old_coinstip_size) {
5499        // Likely no need to flush if cache sizes have grown.
5500        ret = FlushStateToDisk(state, FlushStateMode::IF_NEEDED);