Where validation becomes chain state

1751            if (!m_pool.exists(tx->GetHash())) {
1752                package_state_final.Invalid(PackageValidationResult::PCKG_TX, "transaction failed");
1753                TxValidationState mempool_full_state;
1754                mempool_full_state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "mempool full");
1755                // Replace the previous result.
1756                results_final.erase(wtxid);
1757                results_final.emplace(wtxid, MempoolAcceptResult::Failure(mempool_full_state));
1758            }
1759        } else if (const auto it{individual_results_nonfinal.find(wtxid)}; it != individual_results_nonfinal.end()) {
1760            Assume(it->second.m_result_type == MempoolAcceptResult::ResultType::INVALID);
1761            // Interesting result from previous processing.
1762            results_final.emplace(wtxid, it->second);
1763        }
1764    }
1765    Assume(results_final.size() == package.size());
1766    return PackageMempoolAcceptResult(package_state_final, std::move(results_final));
1767}
1768
1769} // anon namespace
1770
1771MempoolAcceptResult AcceptToMemoryPool(Chainstate& active_chainstate, const CTransactionRef& tx,
1772                                       int64_t accept_time, bool bypass_limits, bool test_accept)
1773{
1774    AssertLockHeld(::cs_main);
1775    assert(active_chainstate.GetMempool() != nullptr);
1776    CTxMemPool& pool{*active_chainstate.GetMempool()};
1777
1778    std::vector<COutPoint> coins_to_uncache;
1779
1780    auto args = MemPoolAccept::ATMPArgs::SingleAccept(accept_time, bypass_limits, coins_to_uncache, test_accept);
1781    MempoolAcceptResult result = MemPoolAccept(pool, active_chainstate).AcceptSingleTransactionAndCleanup(tx, args);
1782
1783    if (result.m_result_type != MempoolAcceptResult::ResultType::VALID) {
1784        // Remove coins that were not present in the coins cache before calling
1785        // AcceptSingleTransaction(); this is to prevent memory DoS in case we receive a large
1786        // number of invalid transactions that attempt to overrun the in-memory coins cache
1787        // (`CCoinsViewCache::cacheCoins`).
1788
1789        for (const COutPoint& hashTx : coins_to_uncache)
1790            active_chainstate.CoinsTip().Uncache(hashTx);
1791        TRACEPOINT(mempool, rejected,
1792                tx->GetHash().data(),
1793                result.m_state.GetRejectReason().c_str()
1794        );
1795    }
1796    // After we've (potentially) uncached entries, ensure our coins cache is still within its size limits
1797    BlockValidationState state_dummy;
1798    active_chainstate.FlushStateToDisk(state_dummy, FlushStateMode::PERIODIC);
1799    return result;
1800}
1801
1802PackageMempoolAcceptResult ProcessNewPackage(Chainstate& active_chainstate, CTxMemPool& pool,
1803                                                   const Package& package, bool test_accept, const std::optional<CFeeRate>& client_maxfeerate)
1804{
1805    AssertLockHeld(cs_main);
1806    assert(!package.empty());
1807    assert(std::all_of(package.cbegin(), package.cend(), [](const auto& tx){return tx != nullptr;}));
1808
1809    std::vector<COutPoint> coins_to_uncache;
1810    auto result = [&]() EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
1811        AssertLockHeld(cs_main);
1812        if (test_accept) {
1813            auto args = MemPoolAccept::ATMPArgs::PackageTestAccept(GetTime(), coins_to_uncache);
1814            return MemPoolAccept(pool, active_chainstate).AcceptMultipleTransactionsAndCleanup(package, args);
1815        } else {
1816            auto args = MemPoolAccept::ATMPArgs::PackageChildWithParents(GetTime(), coins_to_uncache, client_maxfeerate);
1817            return MemPoolAccept(pool, active_chainstate).AcceptPackage(package, args);
1818        }
1819    }();
1820
1821    // Uncache coins pertaining to transactions that were not submitted to the mempool.
1822    if (test_accept || result.m_state.IsInvalid()) {
1823        for (const COutPoint& hashTx : coins_to_uncache) {
1824            active_chainstate.CoinsTip().Uncache(hashTx);
1825        }
1826    }
1827    // Ensure the coins cache is still within limits.
1828    BlockValidationState state_dummy;
1829    active_chainstate.FlushStateToDisk(state_dummy, FlushStateMode::PERIODIC);
1830    return result;
1831}
1832
1833CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusParams)
1834{
1835    int halvings = nHeight / consensusParams.nSubsidyHalvingInterval;
1836    // Force block reward to zero when right shift is undefined.
1837    if (halvings >= 64)
1838        return 0;
1839
1840    CAmount nSubsidy = 50 * COIN;
1841    // Subsidy is cut in half every 210,000 blocks which will occur approximately every 4 years.
1842    nSubsidy >>= halvings;
1843    return nSubsidy;
1844}
1845
1846CoinsViews::CoinsViews(DBParams db_params, CoinsViewOptions options)
1847    : m_dbview{std::move(db_params), std::move(options)},
1848      m_catcherview(&m_dbview) {}
1849
1850void CoinsViews::InitCache(int32_t prevoutfetch_threads)
1851{
1852    AssertLockHeld(::cs_main);
1853    m_cacheview = std::make_unique<CCoinsViewCache>(&m_catcherview);
1854    auto thread_pool{std::make_shared<ThreadPool>("prevout")};
1855    if (prevoutfetch_threads > 0) {
1856        thread_pool->Start(prevoutfetch_threads);
1857        LogInfo("Block input prevout fetching uses %d additional threads", prevoutfetch_threads);
1858    }
1859    m_connect_block_view = std::make_unique<CoinsViewOverlay>(&*m_cacheview, std::move(thread_pool));
1860}
1861
1862Chainstate::Chainstate(
1863    CTxMemPool* mempool,
1864    BlockManager& blockman,
1865    ChainstateManager& chainman,
1866    std::optional<uint256> from_snapshot_blockhash)
1867    : m_mempool(mempool),
1868      m_blockman(blockman),
1869      m_chainman(chainman),
1870      m_assumeutxo(from_snapshot_blockhash ? Assumeutxo::UNVALIDATED : Assumeutxo::VALIDATED),
1871      m_from_snapshot_blockhash(from_snapshot_blockhash) {}
1872
1873fs::path Chainstate::StoragePath() const
1874{
1875    fs::path path{m_chainman.m_options.datadir / "chainstate"};
1876    if (m_from_snapshot_blockhash) {
1877        path += node::SNAPSHOT_CHAINSTATE_SUFFIX;
1878    }
1879    return path;
1880}
1881
1882const CBlockIndex* Chainstate::SnapshotBase() const
1883{
1884    if (!m_from_snapshot_blockhash) return nullptr;
1885    if (!m_cached_snapshot_base) m_cached_snapshot_base = Assert(m_chainman.m_blockman.LookupBlockIndex(*m_from_snapshot_blockhash));
1886    return m_cached_snapshot_base;
1887}
1888
1889const CBlockIndex* Chainstate::TargetBlock() const
1890{
1891    if (!m_target_blockhash) return nullptr;
1892    if (!m_cached_target_block) m_cached_target_block = Assert(m_chainman.m_blockman.LookupBlockIndex(*m_target_blockhash));
1893    return m_cached_target_block;
1894}
1895
1896void Chainstate::SetTargetBlock(CBlockIndex* block)
1897{
1898    if (block) {
1899        m_target_blockhash = block->GetBlockHash();
1900    } else {
1901        m_target_blockhash.reset();
1902    }
1903    m_cached_target_block = block;
1904}
1905
1906void Chainstate::SetTargetBlockHash(uint256 block_hash)
1907{
1908    m_target_blockhash = block_hash;
1909    m_cached_target_block = nullptr;
1910}
1911
1912void Chainstate::InitCoinsDB(
1913    size_t cache_size_bytes,
1914    bool in_memory,
1915    bool should_wipe)
1916{
1917    m_coins_views = std::make_unique<CoinsViews>(
1918        DBParams{
1919            .path = StoragePath(),
1920            .cache_bytes = cache_size_bytes,
1921            .memory_only = in_memory,
1922            .wipe_data = should_wipe,
1923            .obfuscate = true,
1924            .options = m_chainman.m_options.coins_db},
1925        m_chainman.m_options.coins_view);
1926
1927    m_coinsdb_cache_size_bytes = cache_size_bytes;
1928}
1929
1930void Chainstate::InitCoinsCache(size_t cache_size_bytes)
1931{
1932    AssertLockHeld(::cs_main);
1933    assert(m_coins_views != nullptr);
1934    m_coinstip_cache_size_bytes = cache_size_bytes;
1935    m_coins_views->InitCache(m_chainman.m_options.prevoutfetch_threads_num);
1936}
1937
1938// Lock-free: depends on `m_cached_is_ibd`, which is latched by `UpdateIBDStatus()`.
1939bool ChainstateManager::IsInitialBlockDownload() const noexcept
1940{
1941    return m_cached_is_ibd.load(std::memory_order_relaxed);
1942}
1943
1944void Chainstate::CheckForkWarningConditions()
1945{
1946    AssertLockHeld(cs_main);
1947
1948    if (this->GetRole().historical) {
1949        return;
1950    }
1951
1952    if (m_chainman.m_best_invalid && m_chainman.m_best_invalid->nChainWork > m_chain.Tip()->nChainWork + (GetBlockProof(*m_chain.Tip()) * 6)) {
1953        LogWarning("Found invalid chain more than 6 blocks longer than our best chain. This could be due to database corruption or consensus incompatibility with peers.");
1954        m_chainman.GetNotifications().warningSet(
1955            kernel::Warning::LARGE_WORK_INVALID_CHAIN,
1956            _("Warning: Found invalid chain more than 6 blocks longer than our best chain. This could be due to database corruption or consensus incompatibility with peers."));
1957    } else {
1958        m_chainman.GetNotifications().warningUnset(kernel::Warning::LARGE_WORK_INVALID_CHAIN);
1959    }
1960}
1961
1962// Called both upon regular invalid block discovery *and* InvalidateBlock
1963void Chainstate::InvalidChainFound(CBlockIndex* pindexNew)
1964{
1965    AssertLockHeld(cs_main);
1966    if (!m_chainman.m_best_invalid || pindexNew->nChainWork > m_chainman.m_best_invalid->nChainWork) {
1967        m_chainman.m_best_invalid = pindexNew;
1968    }
1969    SetBlockFailureFlags(pindexNew);
1970    if (m_chainman.m_best_header != nullptr && m_chainman.m_best_header->GetAncestor(pindexNew->nHeight) == pindexNew) {
1971        m_chainman.RecalculateBestHeader();
1972    }
1973
1974    LogInfo("%s: invalid block=%s height=%d log2_work=%f date=%s", __func__,
1975      pindexNew->GetBlockHash().ToString(), pindexNew->nHeight,
1976      log(pindexNew->nChainWork.getdouble())/log(2.0), FormatISO8601DateTime(pindexNew->GetBlockTime()));
1977    CBlockIndex *tip = m_chain.Tip();
1978    assert (tip);
1979    LogInfo("%s: current best=%s height=%d log2_work=%f date=%s", __func__,
1980      tip->GetBlockHash().ToString(), m_chain.Height(), log(tip->nChainWork.getdouble())/log(2.0),
1981      FormatISO8601DateTime(tip->GetBlockTime()));
1982    CheckForkWarningConditions();
1983}
1984
1985// Same as InvalidChainFound, above, except not called directly from InvalidateBlock,
1986// which does its own setBlockIndexCandidates management.
1987void Chainstate::InvalidBlockFound(CBlockIndex* pindex, const BlockValidationState& state)
1988{
1989    AssertLockHeld(cs_main);
1990    if (state.GetResult() != BlockValidationResult::BLOCK_MUTATED) {
1991        pindex->nStatus |= BLOCK_FAILED_VALID;
1992        m_blockman.m_dirty_blockindex.insert(pindex);
1993        setBlockIndexCandidates.erase(pindex);
1994        InvalidChainFound(pindex);
1995    }
1996}
1997
1998void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, CTxUndo &txundo, int nHeight)
1999{
2000    // mark inputs spent