THE checkpoint: prune orphaned on startup, verify against blockchain

TheCheckpointStore new methods:
  prune_unverified() — removes all checkpoints with status != verified
  verify_all(block_exists_fn) — checks each pending checkpoint against
    blockchain RPC, marks as verified (block in best chain) or orphaned
  remove() — delete single checkpoint

On startup: prune_unverified() clears stale checkpoints from previous
runs where blocks were orphaned (e.g., race condition with p2pool
submitauxblock vs c2pool submitblock on same merged chain).

Author: frstrtr

src/c2pool/c2pool_refactored.cpp

@@ -1265,7 +1265,11 @@ int main(int argc, char* argv[]) {
                                      << " root=" << cp.the_state_root.GetHex().substr(0, 16) << "...";
                         }
                     );
-                    LOG_INFO << "[THE] Checkpoint store: " << the_store->count() << " existing";
+                    // On startup: prune checkpoints whose blocks are orphaned
+                    size_t pruned = the_store->prune_unverified();
+                    if (pruned > 0)
+                        LOG_INFO << "[THE] Pruned " << pruned << " unverified checkpoints from previous runs";
+                    LOG_INFO << "[THE] Checkpoint store: " << the_store->count() << " verified";
                 } else {
                     LOG_WARNING << "[Pool] Failed to open found blocks LevelDB at " << fblk_db_path;
                 }

src/c2pool/storage/the_checkpoint.hpp

@@ -204,6 +204,65 @@ class TheCheckpointStore {
         return result;
     }
 
+    /// Remove a checkpoint
+    bool remove(const std::string& chain, uint64_t block_height) {
+        auto key = make_key(chain, block_height);
+        return m_store.remove(key);
+    }
+
+    /// Remove all checkpoints with status != 1 (verified)
+    size_t prune_unverified() {
+        auto keys = m_store.list_keys("thecp:", 10000);
+        size_t removed = 0;
+        for (const auto& key : keys) {
+            std::vector<uint8_t> data;
+            if (m_store.get(key, data)) {
+                auto cp = TheCheckpoint::deserialize(data);
+                if (cp.status != 1) { // not verified
+                    m_store.remove(key);
+                    ++removed;
+                }
+            }
+        }
+        return removed;
+    }
+
+    /// Verify all pending checkpoints against a block-exists callback.
+    /// The callback returns true if the block hash is in the best chain.
+    /// Returns number of checkpoints verified or marked orphaned.
+    size_t verify_all(std::function<bool(const std::string& chain,
+                                         const std::string& block_hash)> block_exists_fn) {
+        auto keys = m_store.list_keys("thecp:", 10000);
+        size_t checked = 0;
+        for (const auto& key : keys) {
+            std::vector<uint8_t> data;
+            if (!m_store.get(key, data)) continue;
+            auto cp = TheCheckpoint::deserialize(data);
+            if (cp.status == 1 || cp.status == 2) continue; // already decided
+
+            bool exists = false;
+            try {
+                exists = block_exists_fn(cp.chain, cp.block_hash);
+            } catch (...) {
+                continue; // RPC error — skip
+            }
+
+            if (exists) {
+                cp.status = 1; // verified — block is in best chain
+                LOG_INFO << "[THE] Checkpoint VERIFIED: " << cp.chain
+                         << " height=" << cp.block_height;
+            } else {
+                cp.status = 2; // orphaned — block not in best chain
+                LOG_WARNING << "[THE] Checkpoint ORPHANED: " << cp.chain
+                            << " height=" << cp.block_height
+                            << " hash=" << cp.block_hash;
+            }
+            m_store.put(key, cp.serialize());
+            ++checked;
+        }
+        return checked;
+    }
+
     size_t count() {
         return m_store.list_keys("thecp:", 10000).size();
     }