3251    fs::path temp_db_path{fsbridge::AbsPathJoin(tmppath.parent_path(), fs::u8path(temp_db_name))};
3252
3253    // Only create the on-disk temp directory when not using in-memory mode
3254    std::optional<TemporaryUTXODatabase> temp_db_cleaner;
3255    if (!in_memory) {
3256        temp_db_cleaner.emplace(temp_db_path);
3257    } else {
3258        LogInfo("Using in-memory database for UTXO-set rollback (this may require significant RAM).");
3259    }
3260
3261    // Create temporary database
3262    DBParams db_params{
3263        .path = temp_db_path,
3264        .cache_bytes = 0,
3265        .memory_only = in_memory,
3266        .wipe_data = true,
3267        .obfuscate = false,
3268        .options = DBOptions{}
3269    };
3270
3271    std::unique_ptr<CCoinsViewDB> temp_db = std::make_unique<CCoinsViewDB>(
3272        std::move(db_params),
3273        CoinsViewOptions{}
3274    );
3275
3276    const CBlockIndex* tip = nullptr;
3277    LogInfo("Copying current UTXO set to temporary database.");
3278    {
3279        CCoinsViewCache temp_cache(temp_db.get());
3280        std::unique_ptr<CCoinsViewCursor> cursor;
3281        {
3282            LOCK(::cs_main);
3283            tip = chainstate.m_chain.Tip();
3284            chainstate.ForceFlushStateToDisk(/*wipe_cache=*/false);
3285            cursor = chainstate.CoinsDB().Cursor();
3286        }
3287        temp_cache.SetBestBlock(tip->GetBlockHash());
3288
3289        size_t coins_count = 0;
3290        while (cursor->Valid()) {
3291            node.rpc_interruption_point();
3292
3293            COutPoint key;
3294            Coin coin;
3295            if (cursor->GetKey(key) && cursor->GetValue(coin)) {
3296                temp_cache.AddCoin(key, std::move(coin), false);
3297                coins_count++;
3298
3299                // Log every 10M coins (optimized for mainnet)
3300                if (coins_count % 10'000'000 == 0) {
3301                    LogInfo("Copying UTXO set: %uM coins copied.", coins_count / 1'000'000);
3302                }
3303
3304                // Flush periodically
3305                if (coins_count % 100'000 == 0) {
3306                    temp_cache.Flush();
3307                }
3308            }
3309            cursor->Next();
3310        }
3311
3312        temp_cache.Flush();
3313        LogInfo("UTXO set copy complete: %u coins total", coins_count);
3314    }
3315
3316    LogInfo("Rolling back from height %d to %d", tip->nHeight, target->nHeight);
3317
3318    const CBlockIndex* block_index{tip};
3319    const size_t total_blocks{static_cast<size_t>(block_index->nHeight - target->nHeight)};
3320    CCoinsViewCache rollback_cache(temp_db.get());
3321    rollback_cache.SetBestBlock(block_index->GetBlockHash());
3322    size_t blocks_processed = 0;
3323    int last_progress{0};
3324    DisconnectResult res;
3325
3326    while (block_index->nHeight > target->nHeight) {
3327        node.rpc_interruption_point();
3328
3329        CBlock block;
3330        if (!node.chainman->m_blockman.ReadBlock(block, *block_index)) {
3331            throw JSONRPCError(RPC_INTERNAL_ERROR,
3332                strprintf("Failed to read block at height %d", block_index->nHeight));
3333        }
3334
3335        WITH_LOCK(::cs_main, res = chainstate.DisconnectBlock(block, block_index, rollback_cache));
3336        if (res == DISCONNECT_FAILED) {
3337            throw JSONRPCError(RPC_INTERNAL_ERROR,
3338                strprintf("Failed to roll back block at height %d", block_index->nHeight));
3339        }
3340
3341        blocks_processed++;
3342        int progress{static_cast<int>(blocks_processed * 100 / total_blocks)};
3343        if (progress >= last_progress + 5) {
3344            LogInfo("Rolled back %d%% of blocks.", progress);
3345            last_progress = progress;
3346            rollback_cache.Flush();
3347        }
3348
3349        block_index = block_index->pprev;
3350    }
3351
3352    CHECK_NONFATAL(rollback_cache.GetBestBlock() == target->GetBlockHash());
3353    rollback_cache.Flush();
3354
3355    LogInfo("Rollback complete. Computing UTXO statistics for created txoutset dump.");
3356    std::optional<CCoinsStats> maybe_stats = GetUTXOStats(*temp_db,
3357                                                          chainstate.m_blockman,
3358                                                          CoinStatsHashType::HASH_SERIALIZED,
3359                                                          node.rpc_interruption_point);
3360
3361    if (!maybe_stats) {
3362        throw JSONRPCError(RPC_INTERNAL_ERROR, "Unable to compute UTXO statistics");
3363    }
3364
3365    std::unique_ptr<CCoinsViewCursor> pcursor{temp_db->Cursor()};
3366
3367    LogInfo("Writing snapshot to disk.");
3368    return WriteUTXOSnapshot(chainstate,
3369                             pcursor.get(),
3370                             &(*maybe_stats),
3371                             target,
3372                             std::move(afile),
3373                             path,
3374                             tmppath,
3375                             node.rpc_interruption_point);
3376}
3377
3378std::tuple<std::unique_ptr<CCoinsViewCursor>, CCoinsStats, const CBlockIndex*>
3379PrepareUTXOSnapshot(
3380    Chainstate& chainstate,
3381    const std::function<void()>& interruption_point)
3382{
3383    std::unique_ptr<CCoinsViewCursor> pcursor;
3384    std::optional<CCoinsStats> maybe_stats;
3385    const CBlockIndex* tip;
3386
3387    {
3388        // We need to lock cs_main to ensure that the coinsdb isn't written to
3389        // between (i) flushing coins cache to disk (coinsdb), (ii) getting stats
3390        // based upon the coinsdb, and (iii) constructing a cursor to the
3391        // coinsdb for use in WriteUTXOSnapshot.
3392        //
3393        // Cursors returned by leveldb iterate over snapshots, so the contents
3394        // of the pcursor will not be affected by simultaneous writes during
3395        // use below this block.
3396        //
3397        // See discussion here:
3398        //   https://github.com/bitcoin/bitcoin/pull/15606#discussion_r274479369
3399        //
3400        AssertLockHeld(::cs_main);
3401
3402        chainstate.ForceFlushStateToDisk(/*wipe_cache=*/false);
3403
3404        maybe_stats = GetUTXOStats(chainstate.CoinsDB(), chainstate.m_blockman, CoinStatsHashType::HASH_SERIALIZED, interruption_point);
3405        if (!maybe_stats) {
3406            throw JSONRPCError(RPC_INTERNAL_ERROR, "Unable to read UTXO set");
3407        }
3408
3409        pcursor = chainstate.CoinsDB().Cursor();
3410        tip = CHECK_NONFATAL(chainstate.m_blockman.LookupBlockIndex(maybe_stats->hashBlock));
3411    }
3412
3413    return {std::move(pcursor), *CHECK_NONFATAL(maybe_stats), tip};
3414}
3415
3416UniValue WriteUTXOSnapshot(
3417    Chainstate& chainstate,
3418    CCoinsViewCursor* pcursor,
3419    CCoinsStats* maybe_stats,
3420    const CBlockIndex* tip,
3421    AutoFile&& afile,
3422    const fs::path& path,
3423    const fs::path& temppath,
3424    const std::function<void()>& interruption_point)
3425{
3426    LOG_TIME_SECONDS(strprintf("writing UTXO snapshot at height %s (%s) to file %s (via %s)",
3427        tip->nHeight, tip->GetBlockHash().ToString(),
3428        fs::PathToString(path), fs::PathToString(temppath)));
3429
3430    SnapshotMetadata metadata{chainstate.m_chainman.GetParams().MessageStart(), tip->GetBlockHash(), maybe_stats->coins_count};
3431
3432    afile << metadata;
3433
3434    COutPoint key;
3435    Txid last_hash;
3436    Coin coin;
3437    unsigned int iter{0};
3438    size_t written_coins_count{0};
3439    std::vector<std::pair<uint32_t, Coin>> coins;
3440
3441    // To reduce space the serialization format of the snapshot avoids
3442    // duplication of tx hashes. The code takes advantage of the guarantee by
3443    // leveldb that keys are lexicographically sorted.
3444    // In the coins vector we collect all coins that belong to a certain tx hash
3445    // (key.hash) and when we have them all (key.hash != last_hash) we write
3446    // them to file using the below lambda function.
3447    // See also https://github.com/bitcoin/bitcoin/issues/25675
3448    auto write_coins_to_file = [&](AutoFile& afile, const Txid& last_hash, const std::vector<std::pair<uint32_t, Coin>>& coins, size_t& written_coins_count) {
3449        afile << last_hash;
3450        WriteCompactSize(afile, coins.size());
3451        for (const auto& [n, coin] : coins) {
3452            WriteCompactSize(afile, n);
3453            afile << coin;
3454            ++written_coins_count;
3455        }
3456    };
3457
3458    pcursor->GetKey(key);
3459    last_hash = key.hash;
3460    while (pcursor->Valid()) {
3461        if (iter % 5000 == 0) interruption_point();
3462        ++iter;
3463        if (pcursor->GetKey(key) && pcursor->GetValue(coin)) {
3464            if (key.hash != last_hash) {
3465                write_coins_to_file(afile, last_hash, coins, written_coins_count);
3466                last_hash = key.hash;
3467                coins.clear();
3468            }
3469            coins.emplace_back(key.n, coin);
3470        }
3471        pcursor->Next();
3472    }
3473
3474    if (!coins.empty()) {
3475        write_coins_to_file(afile, last_hash, coins, written_coins_count);
3476    }
3477
3478    CHECK_NONFATAL(written_coins_count == maybe_stats->coins_count);
3479
3480    if (afile.fclose() != 0) {
3481        throw std::ios_base::failure(
3482            strprintf("Error closing %s: %s", fs::PathToString(temppath), SysErrorString(errno)));
3483    }
3484
3485    UniValue result(UniValue::VOBJ);
3486    result.pushKV("coins_written", written_coins_count);
3487    result.pushKV("base_hash", tip->GetBlockHash().ToString());
3488    result.pushKV("base_height", tip->nHeight);
3489    result.pushKV("path", path.utf8string());
3490    result.pushKV("txoutset_hash", maybe_stats->hashSerialized.ToString());
3491    result.pushKV("nchaintx", tip->m_chain_tx_count);
3492    return result;
3493}
3494
3495UniValue CreateUTXOSnapshot(
3496    node::NodeContext& node,
3497    Chainstate& chainstate,
3498    AutoFile&& afile,
3499    const fs::path& path,
3500    const fs::path& tmppath)