Where validation becomes chain state

6001       return SnapshotCompletionResult::SKIPPED;
6002    }
6003    assert(validated_cs.TargetBlock() == validated_cs.m_chain.Tip());
6004
6005    auto handle_invalid_snapshot = [&]() EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
6006        bilingual_str user_error = strprintf(_(
6007            "%s failed to validate the -assumeutxo snapshot state. "
6008            "This indicates a hardware problem, or a bug in the software, or a "
6009            "bad software modification that allowed an invalid snapshot to be "
6010            "loaded. As a result of this, the node will shut down and stop using any "
6011            "state that was built on the snapshot, resetting the chain height "
6012            "from %d to %d. On the next "
6013            "restart, the node will resume syncing from %d "
6014            "without using any snapshot data. "
6015            "Please report this incident to %s, including how you obtained the snapshot. "
6016            "The invalid snapshot chainstate will be left on disk in case it is "
6017            "helpful in diagnosing the issue that caused this error."),
6018            CLIENT_NAME, unvalidated_cs.m_chain.Height(),
6019            validated_cs.m_chain.Height(),
6020            validated_cs.m_chain.Height(), CLIENT_BUGREPORT);
6021
6022        LogError("[snapshot] !!! %s\n", user_error.original);
6023        LogError("[snapshot] deleting snapshot, reverting to validated chain, and stopping node\n");
6024
6025        // Reset chainstate target to network tip instead of snapshot block.
6026        validated_cs.SetTargetBlock(nullptr);
6027
6028        unvalidated_cs.m_assumeutxo = Assumeutxo::INVALID;
6029
6030        auto rename_result = unvalidated_cs.InvalidateCoinsDBOnDisk();
6031        if (!rename_result) {
6032            user_error += Untranslated("\n") + util::ErrorString(rename_result);
6033        }
6034
6035        GetNotifications().fatalError(user_error);
6036    };
6037
6038    CCoinsViewDB& validated_coins_db = validated_cs.CoinsDB();
6039    validated_cs.ForceFlushStateToDisk();
6040
6041    const auto& maybe_au_data = m_options.chainparams.AssumeutxoForHeight(validated_cs.m_chain.Height());
6042    if (!maybe_au_data) {
6043        LogWarning("[snapshot] assumeutxo data not found for height "
6044            "(%d) - refusing to validate snapshot", validated_cs.m_chain.Height());
6045        handle_invalid_snapshot();
6046        return SnapshotCompletionResult::MISSING_CHAINPARAMS;
6047    }
6048
6049    const AssumeutxoData& au_data = *maybe_au_data;
6050    std::optional<CCoinsStats> validated_cs_stats;
6051    LogInfo("[snapshot] computing UTXO stats for background chainstate to validate "
6052        "snapshot - this could take a few minutes");
6053    try {
6054        validated_cs_stats = ComputeUTXOStats(
6055            CoinStatsHashType::HASH_SERIALIZED,
6056            validated_coins_db,
6057            m_blockman,
6058            [&interrupt = m_interrupt] { SnapshotUTXOHashBreakpoint(interrupt); });
6059    } catch (StopHashingException const&) {
6060        return SnapshotCompletionResult::STATS_FAILED;
6061    }
6062
6063    // XXX note that this function is slow and will hold cs_main for potentially minutes.
6064    if (!validated_cs_stats) {
6065        LogWarning("[snapshot] failed to generate stats for validation coins db");
6066        // While this isn't a problem with the snapshot per se, this condition
6067        // prevents us from validating the snapshot, so we should shut down and let the
6068        // user handle the issue manually.
6069        handle_invalid_snapshot();
6070        return SnapshotCompletionResult::STATS_FAILED;
6071    }
6072
6073    // Compare the validated chainstate's UTXO set hash against the hard-coded
6074    // assumeutxo hash we expect.
6075    //
6076    // TODO: For belt-and-suspenders, we could cache the UTXO set
6077    // hash for the snapshot when it's loaded in its chainstate's leveldb. We could then
6078    // reference that here for an additional check.
6079    if (AssumeutxoHash{validated_cs_stats->hashSerialized} != au_data.hash_serialized) {
6080        LogWarning("[snapshot] hash mismatch: actual=%s, expected=%s",
6081            validated_cs_stats->hashSerialized.ToString(),
6082            au_data.hash_serialized.ToString());
6083        handle_invalid_snapshot();
6084        return SnapshotCompletionResult::HASH_MISMATCH;
6085    }
6086
6087    LogInfo("[snapshot] snapshot beginning at %s has been fully validated",
6088        unvalidated_cs.m_from_snapshot_blockhash->ToString());
6089
6090    unvalidated_cs.m_assumeutxo = Assumeutxo::VALIDATED;
6091    validated_cs.m_target_utxohash = AssumeutxoHash{validated_cs_stats->hashSerialized};
6092    this->MaybeRebalanceCaches();
6093
6094    return SnapshotCompletionResult::SUCCESS;
6095}
6096
6097Chainstate& ChainstateManager::ActiveChainstate() const
6098{
6099    LOCK(::cs_main);
6100    return CurrentChainstate();
6101}
6102
6103void ChainstateManager::MaybeRebalanceCaches()
6104{
6105    AssertLockHeld(::cs_main);
6106    Chainstate& current_cs{CurrentChainstate()};
6107    Chainstate* historical_cs{HistoricalChainstate()};
6108    if (!historical_cs && !current_cs.m_from_snapshot_blockhash) {
6109        // Allocate everything to the IBD chainstate. This will always happen
6110        // when we are not using a snapshot.
6111        current_cs.ResizeCoinsCaches(m_total_coinstip_cache, m_total_coinsdb_cache);
6112    } else if (!historical_cs) {
6113        // If background validation has completed and snapshot is our active chain...
6114        LogInfo("[snapshot] allocating all cache to the snapshot chainstate");
6115        // Allocate everything to the snapshot chainstate.
6116        current_cs.ResizeCoinsCaches(m_total_coinstip_cache, m_total_coinsdb_cache);
6117    } else {
6118        // If both chainstates exist, determine who needs more cache based on IBD status.
6119        //
6120        // Note: shrink caches first so that we don't inadvertently overwhelm available memory.
6121        if (IsInitialBlockDownload()) {
6122            historical_cs->ResizeCoinsCaches(
6123                m_total_coinstip_cache * 0.05, m_total_coinsdb_cache * 0.05);
6124            current_cs.ResizeCoinsCaches(
6125                m_total_coinstip_cache * 0.95, m_total_coinsdb_cache * 0.95);
6126        } else {
6127            current_cs.ResizeCoinsCaches(
6128                m_total_coinstip_cache * 0.05, m_total_coinsdb_cache * 0.05);
6129            historical_cs->ResizeCoinsCaches(
6130                m_total_coinstip_cache * 0.95, m_total_coinsdb_cache * 0.95);
6131        }
6132    }
6133}
6134
6135void ChainstateManager::ResetChainstates()
6136{
6137    m_chainstates.clear();
6138}
6139
6140/**
6141 * Apply default chain params to nullopt members.
6142 * This helps to avoid coding errors around the accidental use of the compare
6143 * operators that accept nullopt, thus ignoring the intended default value.
6144 */
6145static ChainstateManager::Options&& Flatten(ChainstateManager::Options&& opts)
6146{
6147    if (!opts.check_block_index.has_value()) opts.check_block_index = opts.chainparams.DefaultConsistencyChecks();
6148    if (!opts.minimum_chain_work.has_value()) opts.minimum_chain_work = UintToArith256(opts.chainparams.GetConsensus().nMinimumChainWork);
6149    if (!opts.assumed_valid_block.has_value()) opts.assumed_valid_block = opts.chainparams.GetConsensus().defaultAssumeValid;
6150    return std::move(opts);
6151}
6152
6153ChainstateManager::ChainstateManager(const util::SignalInterrupt& interrupt, Options options, node::BlockManager::Options blockman_options)
6154    : m_script_check_queue{/*batch_size=*/128, std::clamp(options.worker_threads_num, 0, MAX_SCRIPTCHECK_THREADS)},
6155      m_interrupt{interrupt},
6156      m_options{Flatten(std::move(options))},
6157      m_blockman{interrupt, std::move(blockman_options)},
6158      m_validation_cache{m_options.script_execution_cache_bytes, m_options.signature_cache_bytes}
6159{
6160}
6161
6162ChainstateManager::~ChainstateManager()
6163{
6164    LOCK(::cs_main);
6165
6166    m_versionbitscache.Clear();
6167}
6168
6169Chainstate* ChainstateManager::LoadAssumeutxoChainstate()
6170{
6171    assert(!CurrentChainstate().m_from_snapshot_blockhash);
6172    std::optional<fs::path> path = node::FindAssumeutxoChainstateDir(m_options.datadir);
6173    if (!path) {
6174        return nullptr;
6175    }
6176    std::optional<uint256> base_blockhash = node::ReadSnapshotBaseBlockhash(*path);
6177    if (!base_blockhash) {
6178        return nullptr;
6179    }
6180    LogInfo("[snapshot] detected active snapshot chainstate (%s) - loading",
6181        fs::PathToString(*path));
6182
6183    auto snapshot_chainstate{std::make_unique<Chainstate>(nullptr, m_blockman, *this, base_blockhash)};
6184    LogInfo("[snapshot] switching active chainstate to %s", snapshot_chainstate->ToString());
6185    return &this->AddChainstate(std::move(snapshot_chainstate));
6186}
6187
6188Chainstate& ChainstateManager::AddChainstate(std::unique_ptr<Chainstate> chainstate)
6189{
6190    Chainstate& prev_chainstate{CurrentChainstate()};
6191    assert(prev_chainstate.m_assumeutxo == Assumeutxo::VALIDATED);
6192    // Set target block for historical chainstate to snapshot block.
6193    assert(!prev_chainstate.TargetBlockHash());
6194    prev_chainstate.SetTargetBlockHash(*Assert(chainstate->m_from_snapshot_blockhash));
6195    m_chainstates.push_back(std::move(chainstate));
6196    Chainstate& curr_chainstate{CurrentChainstate()};
6197    assert(&curr_chainstate == m_chainstates.back().get());
6198
6199    // Transfer possession of the mempool to the chainstate.
6200    // Mempool is empty at this point because we're still in IBD.
6201    assert(!prev_chainstate.m_mempool || prev_chainstate.m_mempool->size() == 0);
6202    assert(!curr_chainstate.m_mempool);
6203    std::swap(curr_chainstate.m_mempool, prev_chainstate.m_mempool);
6204    return curr_chainstate;
6205}
6206
6207bool IsBIP30Repeat(const CBlockIndex& block_index)
6208{
6209    return (block_index.nHeight==91842 && block_index.GetBlockHash() == uint256{"00000000000a4d0a398161ffc163c503763b1f4360639393e0e4c8e300e0caec"}) ||
6210           (block_index.nHeight==91880 && block_index.GetBlockHash() == uint256{"00000000000743f190a18c5577a3c2d2a1f610ae9601ac046a38084ccb7cd721"});
6211}
6212
6213bool IsBIP30Unspendable(const uint256& block_hash, int block_height)
6214{
6215    return (block_height==91722 && block_hash == uint256{"00000000000271a2dc26e7667f8419f2e15416dc6955e5a6c6cdf3f2574dd08e"}) ||
6216           (block_height==91812 && block_hash == uint256{"00000000000af0aed4792b1acee3d966af36cf5def14935db8de83d6f9306f2f"});
6217}
6218
6219util::Result<void> Chainstate::InvalidateCoinsDBOnDisk()
6220{
6221    // Should never be called on a non-snapshot chainstate.
6222    assert(m_from_snapshot_blockhash);
6223
6224    // Coins views no longer usable.
6225    m_coins_views.reset();
6226
6227    const fs::path db_path{StoragePath()};
6228    const fs::path invalid_path{db_path + "_INVALID"};
6229    const std::string db_path_str{fs::PathToString(db_path)};
6230    const std::string invalid_path_str{fs::PathToString(invalid_path)};
6231    LogInfo("[snapshot] renaming snapshot datadir %s to %s", db_path_str, invalid_path_str);
6232
6233    // The invalid storage directory is simply moved and not deleted because we may
6234    // want to do forensics later during issue investigation. The user is instructed
6235    // accordingly in MaybeValidateSnapshot().
6236    try {
6237        fs::rename(db_path, invalid_path);
6238    } catch (const fs::filesystem_error& e) {
6239        LogError("While invalidating the coins db: Error renaming file '%s' -> '%s': %s",
6240                 db_path_str, invalid_path_str, e.what());
6241        return util::Error{strprintf(_(
6242            "Rename of '%s' -> '%s' failed. "
6243            "You should resolve this by manually moving or deleting the invalid "
6244            "snapshot directory %s, otherwise you will encounter the same error again "
6245            "on the next startup."),
6246            db_path_str, invalid_path_str, db_path_str)};
6247    }
6248    return {};
6249}
6250