1333@@ -1335,6 +1334,14 @@ int BlockManager::GetSpendHeight(const CCoinsViewCache& inputs)
1334     return pindexPrev->nHeight + 1;
1335 }
1336 
1337+const CBlockIndex* BlockManager::GetLastPruneBlock(const CBlockIndex* start_block) {
1338+    const CBlockIndex* block = start_block;
1339+    CHECK_NONFATAL(block);

3672@@ -3663,6 +3673,10 @@ void BlockManager::FindFilesToPrune(std::set<int>& setFilesToPrune, uint64_t nPr
3673            nLastBlockWeCanPrune, count);
3674 }
3675 
3676+void BlockManager::UpdatePruneBlocker(std::string name, const CBlockIndex* block) {

50@@ -51,6 +51,14 @@ bool IsBlockPruned(const CBlockIndex* pblockindex)
51     return (fHavePruned && !(pblockindex->nStatus & BLOCK_HAVE_DATA) && pblockindex->nTx > 0);
52 }
53 
54+const CBlockIndex* GetLastPruneBlock(const CBlockIndex& start_block) {

449@@ -450,6 +450,10 @@ class BlockManager
450      */
451     int GetSpendHeight(const CCoinsViewCache& inputs) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
452 
453+    std::unordered_map<std::string, const CBlockIndex*> m_prune_blockers;
454+
455+    void UpdatePruneBlocker(std::string name, const CBlockIndex* block) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);

2040@@ -2041,6 +2041,16 @@ bool CChainState::FlushStateToDisk(
2041                last_prune = std::max(1, std::min(last_prune, index.GetSummary().best_block_height));
2042             });
2043 
2044+            for (auto const& blocker : m_blockman.m_prune_blockers) {
2045+                if (blocker.second) {

3672@@ -3663,6 +3673,11 @@ void BlockManager::FindFilesToPrune(std::set<int>& setFilesToPrune, uint64_t nPr
3673            nLastBlockWeCanPrune, count);
3674 }
3675 
3676+void BlockManager::UpdatePruneBlocker(std::string name, const CBlockIndex* block) {
3677+    AssertLockHeld(::cs_main);
3678+    m_prune_blockers[name] = block;

368+void BaseIndex::SetBestBlockIndex(const CBlockIndex* block) {
369+    m_best_block_index = block;
370+    if (AllowPrune()) {
371+        LOCK(::cs_main);
372+        if (!block) {
373+            g_chainman.m_blockman.UpdatePruneBlocker(GetName(), ::ChainActive().Genesis());

1073-    CHECK_NONFATAL(block);
1074-    while (block->pprev && (block->pprev->nStatus & BLOCK_HAVE_DATA)) {
1075-        block = block->pprev;
1076-    }
1077-    return uint64_t(block->nHeight);
1078+    const CBlockIndex* last_block = GetLastPrunedBlock(*active_chain.Tip());

496@@ -494,6 +497,12 @@ class BlockManager
497      */
498     int GetSpendHeight(const CCoinsViewCache& inputs) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
499 
500+    std::unordered_map<std::string, const CBlockIndex*> m_prune_blockers;

3793@@ -3792,6 +3794,21 @@ void BlockManager::FindFilesToPrune(std::set<int>& setFilesToPrune, uint64_t nPr
3794            nLastBlockWeCanPrune, count);
3795 }
3796 
3797+void BlockManager::UpdatePruneBlocker(const std::string& name, const CBlockIndex* block) {
3798+    AssertLockHeld(::cs_main);
3799+    m_prune_blockers[name] = block;
3800+}
3801+
3802+void BlockManager::GetLastPruneBlockerHeight(int& last_prune) {

3802+void BlockManager::GetLastPruneBlockerHeight(int& last_prune) {
3803+    for (auto const& blocker : m_prune_blockers) {
3804+        const int blocker_height = blocker.second->nHeight + PRUNE_BLOCKER_BUFFER;
3805+        last_prune = std::max(1, std::min(last_prune, blocker_height));
3806+        if (last_prune == blocker_height) {
3807+            LogPrintf("%s limited pruning to height %d\n", blocker.first, blocker_height);

3795+    m_prune_blockers[name] = block;
3796+}
3797+
3798+void BlockManager::GetLastPruneBlockerHeight(int& last_prune) {
3799+    for (auto const& blocker : m_prune_blockers) {
3800+        const int blocker_height = blocker.second->nHeight + PRUNE_BLOCKER_BUFFER;

57+        for node in stats_nodes:
58+            assert(node.gettxoutsetinfo(hash_type="muhash", hash_or_height=tip)['muhash'])
59+
60+        # Mine two batches of blocks to avoid hitting NODE_NETWORK_LIMITED_MIN_BLOCKS disconnection
61+        self.mine_batches(2)
62+        self.sync_index(height=700)

365@@ -370,3 +366,11 @@ IndexSummary BaseIndex::GetSummary() const
366     summary.best_block_height = m_best_block_index ? m_best_block_index.load()->nHeight : 0;
367     return summary;
368 }
369+
370+void BaseIndex::SetBestBlockIndex(const CBlockIndex* block) {
371+    m_best_block_index = block;
372+    if (AllowPrune() && (fPruneMode || fHavePruned) && !fReindex) {
373+        LOCK(::cs_main);
374+        g_chainman.m_blockman.UpdatePruneBlocker(GetName(), block ? block : ::ChainActive().Genesis());

71@@ -72,11 +72,7 @@ bool BaseIndex::Init()
72         if (!m_best_block_index) {
73             // index is not built yet
74             // make sure we have all block data back to the genesis
75-            const CBlockIndex* block = active_chain.Tip();
76-            while (block->pprev && (block->pprev->nStatus & BLOCK_HAVE_DATA)) {
77-                block = block->pprev;
78-            }
79-            prune_violation = block != active_chain.Genesis();
80+            prune_violation = GetLastPrunedBlock(active_chain.Tip()) != active_chain.Genesis();

494+     * Map from external index name to most recent block the index can tolerate being pruned.
495+     *
496+     * @note Internally, only blocks at height (block->nHeight - PRUNE_BLOCKER_BUFFER) and
497+     * below will be pruned, but callers should avoid assuming any particular buffer size.
498+     */
499+    std::unordered_map<std::string, const CBlockIndex*> m_prune_blockers;

104+        self.mine_batches(4)
105+
106+        self.log.info("prune further than the indices best blocks while the indices are disabled")
107+        for i in range(3):
108+            pruneheight_new = self.nodes[i].pruneblockchain(1000)
109+            assert_greater_than(pruneheight_new, pruneheight)

65+
66+        # Mine two batches of blocks to avoid hitting NODE_NETWORK_LIMITED_MIN_BLOCKS disconnection
67+        self.mine_batches(2)
68+        self.sync_index(height=700)
69+
70+        self.expected_prune_height(690)

47@@ -48,6 +48,9 @@ extern uint64_t nPruneTarget;
48 //! Check whether the block associated with this index entry is pruned or not.
49 bool IsBlockPruned(const CBlockIndex* pblockindex);
50 
51+//! Find the last block that is pruned
52+const CBlockIndex* GetLastPrunedBlock(const CBlockIndex* start_block);

47@@ -48,6 +48,9 @@ extern uint64_t nPruneTarget;
48 //! Check whether the block associated with this index entry is pruned or not.
49 bool IsBlockPruned(const CBlockIndex* pblockindex);
50 
51+//! Find the first block that is not pruned
52+const CBlockIndex* GetFirstStoredBlock(const CBlockIndex* start_block);

364@@ -369,3 +365,12 @@ IndexSummary BaseIndex::GetSummary() const
365     summary.best_block_height = m_best_block_index ? m_best_block_index.load()->nHeight : 0;
366     return summary;
367 }
368+
369+void BaseIndex::SetBestBlockIndex(const CBlockIndex* block) {

1939@@ -1941,12 +1940,9 @@ bool CChainState::FlushStateToDisk(
1940         CoinsCacheSizeState cache_state = GetCoinsCacheSizeState();
1941         LOCK(cs_LastBlockFile);
1942         if (fPruneMode && (fCheckForPruning || nManualPruneHeight > 0) && !fReindex) {
1943-            // make sure we don't prune above the blockfilterindexes bestblocks
1944+            // make sure we don't prune above any of the prune blockers bestblocks
1945             // pruning is height-based
1946             int last_prune = m_chain.Height(); // last height we can prune
1947-            ForEachBlockFilterIndex([&](BlockFilterIndex& index) {
1948-               last_prune = std::max(1, std::min(last_prune, index.GetSummary().best_block_height));

66@@ -67,7 +67,7 @@ bool BaseIndex::Init()
67         SetBestBlockIndex(m_chainstate->m_blockman.FindForkInGlobalIndex(active_chain, locator));
68     }
69     m_synced = m_best_block_index.load() == active_chain.Tip();
70-    if (!m_synced) {
71+    if (!m_synced && (fPruneMode || fHavePruned) && !fReindex) {

1947@@ -1948,6 +1948,15 @@ bool CChainState::FlushStateToDisk(
1948                last_prune = std::max(1, std::min(last_prune, index.GetSummary().best_block_height));
1949             });
1950 
1951+            for (auto const& blocker : m_blockman.m_prune_blockers) {
1952+                const int blocker_height = blocker.second->nHeight - PRUNE_BLOCKER_BUFFER;

1030@@ -1031,7 +1031,7 @@ static RPCHelpMan pruneblockchain()
1031             "                  to prune blocks whose block time is at least 2 hours older than the provided timestamp."},
1032                 },
1033                 RPCResult{
1034-                    RPCResult::Type::NUM, "", "Height of the last block pruned"},
1035+                    RPCResult::Type::NUM, "", "Height of the first block that is still stored after pruning"},

87@@ -88,6 +88,8 @@ static const unsigned int DEFAULT_CHECKLEVEL = 3;
88 // one 128MB block file + added 15% undo data = 147MB greater for a total of 545MB
89 // Setting the target to >= 550 MiB will make it likely we can respect the target.
90 static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES = 550 * 1024 * 1024;
91+/** Blocks to keep below deepest prune blocker */

3598@@ -3594,6 +3599,11 @@ void BlockManager::FindFilesToPrune(std::set<int>& setFilesToPrune, uint64_t nPr
3599            nLastBlockWeCanPrune, count);
3600 }
3601 
3602+void BlockManager::UpdatePruneBlocker(const std::string& name, const CBlockIndex* block) {
3603+    AssertLockHeld(::cs_main);
3604+    m_prune_blockers[name] = block;

486+     * Map from external index name to most recent block the index can tolerate being pruned.
487+     *
488+     * @note Internally, only blocks at height (block->nHeight - PRUNE_BLOCKER_BUFFER) and
489+     * below will be pruned, but callers should avoid assuming any particular buffer size.
490+     */
491+    std::unordered_map<std::string, const CBlockIndex*> m_prune_blockers GUARDED_BY(::cs_main);

41+        self.connect_nodes(0,2)
42+        self.connect_nodes(0,3)
43+
44+    def mine_batches(self, n):
45+        for _ in range(n):
46+            self.nodes[0].generate(250)

309@@ -310,7 +310,7 @@
310     'feature_help.py',
311     'feature_shutdown.py',
312     'p2p_ibd_txrelay.py',
313-    'feature_blockfilterindex_prune.py'
314+    'feature_index_prune.py'

2229-            ForEachBlockFilterIndex([&](BlockFilterIndex& index) {
2230-               last_prune = std::max(1, std::min(last_prune, index.GetSummary().best_block_height));
2231-            });
2232+
2233+            for (const auto& blocker : m_blockman.m_prune_blockers) {
2234+                const int blocker_height{blocker.second->nHeight - PRUNE_BLOCKER_BUFFER};

464+     * @note Internally, only blocks at height (block->nHeight - PRUNE_BLOCKER_BUFFER) and
465+     * below will be pruned, but callers should avoid assuming any particular buffer size.
466+     */
467+    std::unordered_map<std::string, const CBlockIndex*> m_prune_blockers GUARDED_BY(::cs_main);
468+
469+    void UpdatePruneBlocker(const std::string& name, const CBlockIndex* block) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);

462+     * Map from external index name to most recent block the index can tolerate being pruned.
463+     *
464+     * @note Internally, only blocks at height (block->nHeight - PRUNE_BLOCKER_BUFFER) and
465+     * below will be pruned, but callers should avoid assuming any particular buffer size.
466+     */
467+    std::unordered_map<std::string, const CBlockIndex*> m_prune_blockers GUARDED_BY(::cs_main);

50@@ -51,6 +51,15 @@ bool IsBlockPruned(const CBlockIndex* pblockindex)
51     return (fHavePruned && !(pblockindex->nStatus & BLOCK_HAVE_DATA) && pblockindex->nTx > 0);
52 }
53 
54+const CBlockIndex* GetFirstStoredBlock(const CBlockIndex* start_block) {
55+    CHECK_NONFATAL(start_block);
56+    const CBlockIndex* last_block = start_block;
57+    while (last_block->pprev && (last_block->pprev->nStatus & BLOCK_HAVE_DATA)) {

1114@@ -1115,7 +1115,7 @@ static RPCHelpMan pruneblockchain()
1115             "                  to prune blocks whose block time is at least 2 hours older than the provided timestamp."},
1116                 },
1117                 RPCResult{
1118-                    RPCResult::Type::NUM, "", "Height of the last block pruned"},
1119+                    RPCResult::Type::NUM, "", "The height of the first block that is still stored after pruning"},

34@@ -35,6 +35,7 @@
35 #include <stdint.h>
36 #include <string>
37 #include <thread>
38+#include <unordered_map>

2478+    {
2479+        // Prune blockers that began at or after the tip should get moved backward so they get a chance to reorg
2480+        const int max_height_first = pindexDelete->nHeight - 1;
2481+        for (auto& prune_blocker : m_blockman.m_prune_blockers) {
2482+            if (prune_blocker.second.m_height_first <= max_height_first) continue;
2483+            // NOTE: Don't need to write to db here, since it will get synced when the rest of the chainstate

379+    m_best_block_index = block;
380+    if (AllowPrune() && block) {
381+        node::PruneBlockerInfo prune_blocker;
382+        prune_blocker.m_height_first = block->nHeight;
383+        LOCK(::cs_main);
384+        m_chainstate->m_blockman.UpdatePruneBlocker(GetName(), prune_blocker);

102@@ -103,6 +103,8 @@ class BaseIndex : public CValidationInterface
103     /// Get the name of the index for display in logs.
104     virtual const char* GetName() const = 0;
105 
106+    virtual bool AllowPrune() const = 0;

416@@ -417,7 +417,7 @@ void SetupServerArgs(ArgsManager& argsman)
417         -GetNumCores(), MAX_SCRIPTCHECK_THREADS, DEFAULT_SCRIPTCHECK_THREADS), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
418     argsman.AddArg("-persistmempool", strprintf("Whether to save the mempool on shutdown and load on restart (default: %u)", DEFAULT_PERSIST_MEMPOOL), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
419     argsman.AddArg("-pid=<file>", strprintf("Specify pid file. Relative paths will be prefixed by a net-specific datadir location. (default: %s)", BITCOIN_PID_FILENAME), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
420-    argsman.AddArg("-prune=<n>", strprintf("Reduce storage requirements by enabling pruning (deleting) of old blocks. This allows the pruneblockchain RPC to be called to delete specific blocks, and enables automatic pruning of old blocks if a target size in MiB is provided. This mode is incompatible with -txindex and -coinstatsindex. "
421+    argsman.AddArg("-prune=<n>", strprintf("Reduce storage requirements by enabling pruning (deleting) of old blocks. This allows the pruneblockchain RPC to be called to delete specific blocks, and enables automatic pruning of old blocks if a target size in MiB is provided. This mode is incompatible with -txindex. "

 99@@ -100,6 +100,8 @@ static const unsigned int DEFAULT_CHECKLEVEL = 3;
100 // one 128MB block file + added 15% undo data = 147MB greater for a total of 545MB
101 // Setting the target to >= 550 MiB will make it likely we can respect the target.
102 static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES = 550 * 1024 * 1024;
103+/** The number of blocks to keep below the deepest prune lock. */
104+static constexpr int PRUNE_LOCK_BUFFER{10};

378+
379+    m_best_block_index = block;
380+    if (AllowPrune() && block) {
381+        node::PruneLockInfo prune_lock;
382+        prune_lock.m_height_first = block->nHeight;
383+        WITH_LOCK(::cs_main, m_chainstate->m_blockman.UpdatePruneLock(GetName(), prune_lock));

2472@@ -2468,6 +2473,18 @@ bool CChainState::DisconnectTip(BlockValidationState& state, DisconnectedBlockTr
2473         assert(flushed);
2474     }
2475     LogPrint(BCLog::BENCH, "- Disconnect block: %.2fms\n", (GetTimeMicros() - nStart) * MILLI);
2476+
2477+    {
2478+        // Prune locks that began at or after the tip should get moved backward so they get a chance to reorg
2479+        const int max_height_first = pindexDelete->nHeight - 1;
2480+        for (auto& prune_lock : m_blockman.m_prune_locks) {

160@@ -156,6 +161,16 @@ class BlockManager
161     //! Returns last CBlockIndex* that is a checkpoint
162     CBlockIndex* GetLastCheckpoint(const CCheckpointData& data) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
163 
164+    /**
165+     * Map from external index name to most recent block the index can tolerate being pruned.

2234+
2235+            for (const auto& prune_lock : m_blockman.m_prune_locks) {
2236+                if (prune_lock.second.m_height_first == std::numeric_limits<int>::max()) continue;
2237+                const int lock_height{prune_lock.second.m_height_first - PRUNE_LOCK_BUFFER};
2238+                last_prune = std::max(1, std::min(last_prune, lock_height));
2239+                if (last_prune == lock_height) {

2477+    {
2478+        // Prune locks that began at or after the tip should get moved backward so they get a chance to reorg
2479+        const int max_height_first = pindexDelete->nHeight - 1;
2480+        for (auto& prune_lock : m_blockman.m_prune_locks) {
2481+            if (prune_lock.second.m_height_first <= max_height_first) continue;
2482+            // NOTE: Don't need to write to db here, since it will get synced with the rest of the chainstate

2223@@ -2225,12 +2224,18 @@ bool CChainState::FlushStateToDisk(
2224         CoinsCacheSizeState cache_state = GetCoinsCacheSizeState();
2225         LOCK(m_blockman.cs_LastBlockFile);
2226         if (fPruneMode && (m_blockman.m_check_for_pruning || nManualPruneHeight > 0) && !fReindex) {
2227-            // make sure we don't prune above the blockfilterindexes bestblocks
2228+            // make sure we don't prune above any of the prune locks bestblocks
2229             // pruning is height-based
2230             int last_prune = m_chain.Height(); // last height we can prune
2231-            ForEachBlockFilterIndex([&](BlockFilterIndex& index) {

872     if (args.GetIntArg("-prune", 0)) {
873         if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX))
874             return InitError(_("Prune mode is incompatible with -txindex."));
875-        if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX))
876-            return InitError(_("Prune mode is incompatible with -coinstatsindex."));
877     }

55@@ -55,6 +56,10 @@ struct CBlockIndexWorkComparator {
56     bool operator()(const CBlockIndex* pa, const CBlockIndex* pb) const;
57 };
58 
59+struct PruneLockInfo {
60+    int m_height_first{std::numeric_limits<int>::max()};

160@@ -156,6 +161,16 @@ class BlockManager
161     //! Returns last CBlockIndex* that is a checkpoint
162     CBlockIndex* GetLastCheckpoint(const CCheckpointData& data) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
163 
164+    /**
165+     * Map from external index name to oldest block that must not be pruned.
166+     *
167+     * @note Internally, only blocks at height (block->nHeight - PRUNE_LOCK_BUFFER) and

2235+                last_prune = std::max(1, std::min(last_prune, index.GetSummary().best_block_height));
2236             });
2237 
2238+            for (const auto& prune_lock : m_blockman.m_prune_locks) {
2239+                if (prune_lock.second.m_height_first == std::numeric_limits<int>::max()) continue;
2240+                const int lock_height{prune_lock.second.m_height_first - PRUNE_LOCK_BUFFER};

2481@@ -2468,6 +2482,18 @@ bool CChainState::DisconnectTip(BlockValidationState& state, DisconnectedBlockTr
2482         assert(flushed);
2483     }
2484     LogPrint(BCLog::BENCH, "- Disconnect block: %.2fms\n", (GetTimeMicros() - nStart) * MILLI);
2485+
2486+    {
2487+        // Prune locks that began at or after the tip should get moved backward so they get a chance to reorg

743@@ -744,7 +744,7 @@ static RPCHelpMan pruneblockchain()
744             "                  to prune blocks whose block time is at least 2 hours older than the provided timestamp."},
745                 },
746                 RPCResult{
747-                    RPCResult::Type::NUM, "", "Height of the last block pruned"},
748+                    RPCResult::Type::NUM, "", "The height of the first (lowest) block that is still stored, after pruning"},

396@@ -397,6 +397,16 @@ bool IsBlockPruned(const CBlockIndex* pblockindex)
397     return (fHavePruned && !(pblockindex->nStatus & BLOCK_HAVE_DATA) && pblockindex->nTx > 0);
398 }
399 
400+const CBlockIndex* GetFirstStoredBlock(const CBlockIndex* start_block) {
401+    AssertLockHeld(::cs_main);
402+    CHECK_NONFATAL(start_block);

2287-               last_prune = std::max(1, std::min(last_prune, index.GetSummary().best_block_height));
2288+                last_prune = std::max(1, std::min(last_prune, index.GetSummary().best_block_height));
2289             });
2290 
2291+            for (const auto& prune_lock : m_blockman.m_prune_locks) {
2292+                if (prune_lock.second.height_first == std::numeric_limits<int>::max()) continue;