Implement block acceptance verification system

Parent blocks are now verified after submission via async checks at
+10s, +30s, and +120s.  The verification callback checks if the block
hash appears in the header chain (embedded mode) or queries the daemon
via RPC.

Status tracking:
- FoundBlock now has status (pending/confirmed/orphaned/stale) and
  check_count fields
- /recent_blocks REST endpoint includes "status" and "checks" fields
- Verification results are logged: "Block CONFIRMED" or "Block ORPHANED"

Architecture:
- set_block_verify_fn() accepts a callback: returns >0=confirmed,
  <0=orphaned, 0=pending
- schedule_block_verification() fires timers at +10s, +30s, +120s
- Works with both embedded (header chain lookup) and RPC (getblock)
  backends — ready for future DOGE embedded P2P node

For merged blocks: submitauxblock RPC already returns success/failure.
Full async verification (delayed getblock) will be added when the
embedded DOGE P2P node is implemented.

Author: frstrtr

src/c2pool/c2pool_refactored.cpp

@@ -1099,6 +1099,19 @@ int main(int argc, char* argv[]) {
                 // Wire embedded node + header-sync callback (now that web_server is alive)
                 web_server.set_embedded_node(embedded_node.get());
 
+                // Wire block verification: check header chain for found blocks
+                auto* mi = web_server.get_mining_interface();
+                mi->set_io_context(&ioc);
+                mi->set_block_verify_fn(
+                    [chain = embedded_chain.get()](const std::string& hash_hex) -> int {
+                        uint256 h;
+                        h.SetHex(hash_hex);
+                        auto entry = chain->get_header(h);
+                        if (entry.has_value())
+                            return 1;  // confirmed — in our chain
+                        return 0;      // unknown — still pending
+                    });
+
                 // Header validation thread pool (1 thread) — keeps scrypt off io_context.
                 // Shared_ptr so it stays alive for the lifetime of the callbacks.
                 auto hdr_pool = std::make_shared<boost::asio::thread_pool>(1);
@@ -1338,6 +1351,9 @@ int main(int argc, char* argv[]) {
                     }
                 }
                 web_server.get_mining_interface()->record_found_block(height, block_hash);
+                // Schedule async verification at +10s, +30s, +120s
+                if (stale_info == 0)
+                    web_server.get_mining_interface()->schedule_block_verification(block_hash.GetHex());
 
                 const char* stale_str = (stale_info == 253) ? " [ORPHAN — stale prev]"
                                       : (stale_info == 254) ? " [DOA — daemon rejected]"

src/core/web_server.cpp

@@ -2093,10 +2093,18 @@ nlohmann::json MiningInterface::rest_fee()
 
 nlohmann::json MiningInterface::rest_recent_blocks()
 {
+    static const char* status_str[] = {"pending", "confirmed", "orphaned", "stale"};
     nlohmann::json arr = nlohmann::json::array();
     std::lock_guard<std::mutex> lock(m_blocks_mutex);
-    for (const auto& b : m_found_blocks)
-        arr.push_back({{"height", b.height}, {"hash", b.hash}, {"ts", b.ts}});
+    for (const auto& b : m_found_blocks) {
+        arr.push_back({
+            {"height", b.height},
+            {"hash", b.hash},
+            {"ts", b.ts},
+            {"status", status_str[static_cast<int>(b.status)]},
+            {"checks", b.check_count}
+        });
+    }
     return arr;
 }
 
@@ -2362,11 +2370,76 @@ void MiningInterface::record_found_block(uint64_t height, const uint256& hash, u
 {
     if (ts == 0) ts = static_cast<uint64_t>(std::time(nullptr));
     std::lock_guard<std::mutex> lock(m_blocks_mutex);
-    m_found_blocks.insert(m_found_blocks.begin(), FoundBlock{height, hash.GetHex(), ts});
+    m_found_blocks.insert(m_found_blocks.begin(),
+        FoundBlock{height, hash.GetHex(), ts, BlockStatus::pending, 0});
     if (m_found_blocks.size() > 100)
         m_found_blocks.resize(100);
 }
 
+void MiningInterface::set_block_verify_fn(block_verify_fn_t fn) { m_block_verify_fn = std::move(fn); }
+
+void MiningInterface::verify_found_block(size_t index)
+{
+    std::string hash;
+    {
+        std::lock_guard<std::mutex> lock(m_blocks_mutex);
+        if (index >= m_found_blocks.size()) return;
+        auto& blk = m_found_blocks[index];
+        if (blk.status != BlockStatus::pending) return;
+        blk.check_count++;
+        hash = blk.hash;
+    }
+
+    if (!m_block_verify_fn) return;
+
+    // Callback returns: >0 confirmed, <0 orphaned, 0 unknown/pending
+    int result = 0;
+    try { result = m_block_verify_fn(hash); } catch (...) {}
+
+    std::lock_guard<std::mutex> lock(m_blocks_mutex);
+    if (index >= m_found_blocks.size()) return;
+    auto& blk = m_found_blocks[index];
+    if (blk.status != BlockStatus::pending) return;
+
+    if (result > 0) {
+        blk.status = BlockStatus::confirmed;
+        LOG_INFO << "Block CONFIRMED: height=" << blk.height
+                 << " hash=" << blk.hash.substr(0, 16) << "..."
+                 << " (check #" << (int)blk.check_count << ")";
+    } else if (result < 0 || blk.check_count >= 3) {
+        blk.status = BlockStatus::orphaned;
+        LOG_WARNING << "Block ORPHANED: height=" << blk.height
+                    << " hash=" << blk.hash.substr(0, 16) << "..."
+                    << " (check #" << (int)blk.check_count << ")";
+    }
+}
+
+void MiningInterface::schedule_block_verification(const std::string& block_hash)
+{
+    // Find the block index by hash
+    size_t idx = SIZE_MAX;
+    {
+        std::lock_guard<std::mutex> lock(m_blocks_mutex);
+        for (size_t i = 0; i < m_found_blocks.size(); ++i) {
+            if (m_found_blocks[i].hash == block_hash) {
+                idx = i;
+                break;
+            }
+        }
+    }
+    if (idx == SIZE_MAX) return;
+
+    // Schedule checks at +10s, +30s, +120s after block submission
+    auto& ioc = *m_context;
+    for (int delay : {10, 30, 120}) {
+        auto timer = std::make_shared<boost::asio::steady_timer>(
+            ioc, std::chrono::seconds(delay));
+        timer->async_wait([this, idx, timer](boost::system::error_code ec) {
+            if (!ec) verify_found_block(idx);
+        });
+    }
+}
+
 // ──────────── p2pool legacy compatibility REST endpoints ─────────────────
 // These endpoints reproduce the exact JSON shape that the original p2pool
 // dashboard (Forrest Voight) and jtoomim fork expect, enabling third-party

src/core/web_server.hpp

@@ -428,6 +428,13 @@ class MiningInterface : public jsonrpccxx::JsonRpc2Server
 
     WorkSnapshot get_work_snapshot() const;
 
+    // Block acceptance verification: schedule async checks at +10s, +30s, +120s.
+    // The verify callback returns: >0=confirmed, <0=orphaned, 0=pending.
+    using block_verify_fn_t = std::function<int(const std::string& hash)>;
+    void set_block_verify_fn(block_verify_fn_t fn);
+    void set_io_context(boost::asio::io_context* ctx) { m_context = ctx; }
+    void schedule_block_verification(const std::string& block_hash);
+
     // Callback fired whenever a block submission is attempted.
     // Arguments: header hex (first 80 bytes), stale_info (none=accepted, orphan=stale prev, doa=daemon rejected).
     void set_on_block_submitted(std::function<void(const std::string& header_hex, int stale_info)> fn);
@@ -499,6 +506,8 @@ class MiningInterface : public jsonrpccxx::JsonRpc2Server
     ltc::interfaces::Node*       m_coin_node      = nullptr;
     // Phase 4: embedded coin node (preferred over RPC when set)
     ltc::coin::CoinNodeInterface* m_embedded_node = nullptr;
+    // io_context for scheduling async verification timers
+    boost::asio::io_context*     m_context        = nullptr;
     std::atomic<bool>       m_work_valid{false};
     nlohmann::json          m_cached_template;
     std::vector<std::string> m_cached_merkle_branches;   // Stratum merkle branches
@@ -567,10 +576,25 @@ class MiningInterface : public jsonrpccxx::JsonRpc2Server
     std::atomic<double> m_network_difficulty{0.0};
 
     // Recently found blocks for /recent_blocks
-    struct FoundBlock { uint64_t height; std::string hash; uint64_t ts; };
+    enum class BlockStatus : uint8_t {
+        pending   = 0,  // submitted, awaiting confirmation
+        confirmed = 1,  // in best chain (confirmations > 0)
+        orphaned  = 2,  // replaced by another block at same height
+        stale     = 3,  // submitted with stale prev_block
+    };
+    struct FoundBlock {
+        uint64_t    height;
+        std::string hash;
+        uint64_t    ts;
+        BlockStatus status{BlockStatus::pending};
+        uint8_t     check_count{0};   // how many verification attempts
+    };
     std::vector<FoundBlock> m_found_blocks;   // newest first, capped at 100
     mutable std::mutex      m_blocks_mutex;
 
+    block_verify_fn_t m_block_verify_fn;
+    void verify_found_block(size_t index);
+
     // Pool start time for /uptime
     std::chrono::steady_clock::time_point m_start_time{std::chrono::steady_clock::now()};