Add runtime LevelDB pruning: batch-delete shares evicted by clean_tracker

Matches p2pool main.py:269-270 (tracker.removed.watch → ss.forget_share).
Previously LevelDB was only pruned at startup, growing unbounded at runtime.
Now chain.on_removed buffers hashes, flushed as atomic WriteBatch after
drop-tails. Crash-safe: unflushed shares cleaned up by load_persisted_shares.

Author: frstrtr

src/c2pool/storage/sharechain_storage.cpp

@@ -182,6 +182,13 @@ bool SharechainStorage::remove_share(const uint256& hash)
     return m_leveldb_store->remove_share(hash);
 }
 
+bool SharechainStorage::remove_shares_batch(const std::vector<uint256>& hashes)
+{
+    if (!m_leveldb_store || hashes.empty())
+        return false;
+    return m_leveldb_store->remove_shares_batch(hashes);
+}
+
 bool SharechainStorage::load_share(const uint256& hash, std::vector<uint8_t>& serialized_data,
                 core::ShareMetadata& metadata)
 {

src/c2pool/storage/sharechain_storage.hpp

@@ -125,6 +125,9 @@ class SharechainStorage {
      */
     bool remove_share(const uint256& hash);
 
+    /// Batch-remove multiple shares from LevelDB in one WriteBatch.
+    bool remove_shares_batch(const std::vector<uint256>& hashes);
+
     /// Batch-mark shares as verified in LevelDB metadata.
     bool mark_shares_verified(const std::vector<uint256>& hashes);
 

src/core/leveldb_store.cpp

@@ -678,6 +678,46 @@ bool SharechainLevelDBStore::remove_share(const uint256& hash)
     }
 }
 
+bool SharechainLevelDBStore::remove_shares_batch(const std::vector<uint256>& hashes)
+{
+    if (!m_store || hashes.empty())
+        return false;
+
+    try {
+        auto batch = m_store->create_batch();
+        size_t removed = 0;
+
+        for (const auto& hash : hashes)
+        {
+            // Load metadata for height key removal
+            ShareMetadata metadata;
+            std::vector<uint8_t> dummy;
+            bool had_meta = load_share(hash, dummy, metadata);
+
+            batch.remove(make_share_key(hash));
+            batch.remove(make_index_key(hash));
+            if (had_meta && metadata.height > 0)
+                batch.remove(make_height_key(metadata.height));
+            ++removed;
+        }
+
+        if (!batch.commit()) {
+            LOG_ERROR << "[LevelDB] batch remove failed, count=" << hashes.size();
+            return false;
+        }
+
+        if (m_metadata.total_shares >= removed)
+            m_metadata.total_shares -= removed;
+        else
+            m_metadata.total_shares = 0;
+
+        return true;
+    } catch (const std::exception& e) {
+        LOG_ERROR << "[LevelDB] batch remove exception: " << e.what();
+        return false;
+    }
+}
+
 bool SharechainLevelDBStore::mark_shares_verified(const std::vector<uint256>& hashes)
 {
     if (!m_store || hashes.empty())

src/core/leveldb_store.hpp

@@ -166,6 +166,9 @@ class SharechainLevelDBStore
     bool has_share(const uint256& hash);
     bool remove_share(const uint256& hash);
 
+    /// Batch-remove multiple shares in a single WriteBatch (much faster than per-share remove).
+    bool remove_shares_batch(const std::vector<uint256>& hashes);
+
     /// Batch-update the is_verified flag for multiple shares without rewriting share data.
     bool mark_shares_verified(const std::vector<uint256>& hashes);
 

src/impl/ltc/node.cpp

@@ -1607,6 +1607,17 @@ void NodeImpl::clean_tracker()
     // Step 4: Update best share (p2pool node.py:402)
     run_think();
 
+    // Step 5: Flush pruned shares from LevelDB (p2pool main.py:269-270)
+    if (!m_removal_flush_buf.empty() && m_storage && m_storage->is_available())
+    {
+        auto count = m_removal_flush_buf.size();
+        if (m_storage->remove_shares_batch(m_removal_flush_buf))
+            LOG_INFO << "[clean-leveldb] removed " << count << " pruned shares from LevelDB";
+        else
+            LOG_WARNING << "[clean-leveldb] batch remove failed, count=" << count;
+        m_removal_flush_buf.clear();
+    }
+
     // Orphan/fork diagnostics — understand chain topology
     {
         auto& chain = m_tracker.chain;

src/impl/ltc/node.hpp

@@ -67,6 +67,9 @@ class NodeImpl : public pool::BaseNode<ltc::Config, ltc::ShareChain, ltc::Peer>
     // Buffer of newly verified share hashes, flushed to LevelDB periodically
     std::vector<uint256> m_verified_flush_buf;
 
+    // Buffer of pruned share hashes, batch-deleted from LevelDB after clean_tracker()
+    std::vector<uint256> m_removal_flush_buf;
+
 public:
     NodeImpl()
         : m_share_getter(nullptr,
@@ -103,6 +106,13 @@ class NodeImpl : public pool::BaseNode<ltc::Config, ltc::ShareChain, ltc::Peer>
             if (m_verified_flush_buf.size() >= 50)
                 flush_verified_to_leveldb();
         };
+
+        // Wire up share removal → LevelDB cleanup (p2pool main.py:269-270)
+        // Buffer removals; clean_tracker() flushes after drop-tails.
+        // Safe on crash: unflushed shares get pruned at next startup by load_persisted_shares().
+        m_tracker.chain.on_removed([this](const uint256& hash) {
+            m_removal_flush_buf.push_back(hash);
+        });
     }
 
     // INetwork: Pool node does not initiate disconnect — peer connections