bch(m5): in-flight timeout/eviction for the block-download window

The windowed block download (2cc7de4) deferred stalling-peer handling until
block bodies actually flowed end-to-end -- they now do (NodeP2P enqueues each
synced headers batch and getdatas through the bounded window). This adds the
eviction leg: BlockDownloadWindow now records the issue tick per in-flight
request (next_requests(now_tick)) and exposes expire(now, timeout), which drops
any request older than the timeout, frees its window slot, and re-queues the
stalled hash at the FRONT so it is retried ahead of not-yet-requested tip
blocks. A block delivered after its eviction is reported unsolicited but still
applied. Without this a single non-delivering peer could pin a window slot
forever and wedge IBD.

Periodic-tick wiring into the NodeP2P poll loop is the next micro-slice; this
lands the pure, peer-free state machine + unit coverage first (same shape as the
windowed-download slice).

bch_block_download_test: +2 cases (full-window expiry + re-queue ahead of fresh
hashes; partial expiry leaving fresh requests; post-eviction delivery reported
unsolicited). ctest 11/11 green. Header-only, build-inert (bch skip-green). Zero
p2pool-merged-v36 surface -- pure SPV/IBD wire-sync; per-coin isolation.

Author: frstrtr

src/impl/bch/coin/block_download.hpp

@@ -39,7 +39,9 @@
 // ---------------------------------------------------------------------------
 
 #include <cstddef>
+#include <cstdint>
 #include <deque>
+#include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
@@ -85,13 +87,13 @@ class BlockDownloadWindow {
     /// Pop hashes to request now, up to the free window slots
     /// (max_in_flight - in_flight). Marks them in flight. Oldest-first
     /// (chain order) so block bodies are pulled in the order they were learned.
-    std::vector<uint256> next_requests()
+    std::vector<uint256> next_requests(uint64_t now_tick = 0)
     {
         std::vector<uint256> out;
         while (m_in_flight.size() < m_max_in_flight && !m_queue.empty()) {
             uint256 h = m_queue.front();
             m_queue.pop_front();
-            m_in_flight.insert(h);
+            m_in_flight.emplace(h, now_tick);
             out.push_back(h);
         }
         return out;
@@ -114,6 +116,34 @@ class BlockDownloadWindow {
         return true;
     }
 
+    /// Evict in-flight requests that have gone stale -- a block we getdata'd but a
+    /// stalling peer never delivered. now_tick and timeout_ticks are in the caller's
+    /// monotonic unit (the same unit passed to next_requests()); any request issued
+    /// at issue_tick with now_tick - issue_tick >= timeout_ticks is pushed back to
+    /// the FRONT of the queue (retry oldest-first, ahead of not-yet-requested hashes)
+    /// and dropped from the in-flight set, freeing its window slot. The hash stays in
+    /// m_known (still wanted, still deduped). Returns the evicted hashes so the caller
+    /// can log / consider peer demotion. A block that arrives after eviction is handled
+    /// normally (on_block_received reports it unsolicited, but emit_full_block still
+    /// applies it). Deferred from the windowed-download slice (2cc7de44) until block
+    /// bodies actually flowed end-to-end.
+    std::vector<uint256> expire(uint64_t now_tick, uint64_t timeout_ticks)
+    {
+        std::vector<uint256> evicted;
+        for (auto it = m_in_flight.begin(); it != m_in_flight.end(); ) {
+            if (now_tick - it->second >= timeout_ticks) {
+                evicted.push_back(it->first);
+                it = m_in_flight.erase(it);
+            } else {
+                ++it;
+            }
+        }
+        // Re-queue the stalled hashes ahead of not-yet-requested ones so a stuck
+        // block is retried before fresh tip blocks.
+        for (const auto& h : evicted) m_queue.push_front(h);
+        return evicted;
+    }
+
     std::size_t in_flight()     const { return m_in_flight.size(); }
     std::size_t queued()        const { return m_queue.size(); }
     std::size_t max_in_flight() const { return m_max_in_flight; }
@@ -125,7 +155,7 @@ class BlockDownloadWindow {
 private:
     std::size_t m_max_in_flight;
     std::deque<uint256> m_queue;                            // pending, chain order
-    std::unordered_set<uint256, HashHasher> m_in_flight;    // outstanding getdata
+    std::unordered_map<uint256, uint64_t, HashHasher> m_in_flight; // hash -> tick getdata issued
     std::unordered_set<uint256, HashHasher> m_known;        // queued ∪ inflight ∪ received
 };
 

src/impl/bch/test/block_download_test.cpp

@@ -131,6 +131,51 @@ int main()
         assert(DEFAULT_MAX_BLOCKS_IN_FLIGHT == 16);
     }
 
+    // ---- expire(): stalled in-flight requests are evicted + re-queued ------
+    {
+        BlockDownloadWindow w(2);
+        w.enqueue(hashes(0, 4));                    // [H0 H1 H2 H3]
+        auto req = w.next_requests(/*now=*/100);    // H0,H1 issued @100
+        assert(req.size() == 2);
+        assert(w.in_flight() == 2 && w.queued() == 2);
+
+        // Not yet past the timeout: nothing evicted.
+        assert(w.expire(/*now=*/105, /*timeout=*/10).empty());
+        assert(w.in_flight() == 2);
+
+        // Past the timeout (110-100 >= 10): both stalled requests evicted,
+        // window freed, and they go back to the FRONT of the queue.
+        auto evicted = w.expire(/*now=*/110, /*timeout=*/10);
+        assert(evicted.size() == 2);
+        assert(w.in_flight() == 0);
+        assert(w.queued() == 4);                    // H0,H1 re-queued ahead of H2,H3
+
+        // Retried oldest-first: the next window pulls exactly the two stalled
+        // hashes (ahead of the never-requested H2/H3).
+        auto retry = w.next_requests(/*now=*/200);
+        assert(retry.size() == 2);
+        std::vector<uint256> rset(retry.begin(), retry.end());
+        assert((rset[0] == H(0) || rset[0] == H(1)));
+        assert((rset[1] == H(0) || rset[1] == H(1)) && rset[0] != rset[1]);
+    }
+
+    // ---- expire(): only the stale request goes, fresh ones stay -----------
+    {
+        BlockDownloadWindow w(2);
+        w.enqueue(hashes(0, 3));                    // [H0 H1 H2]
+        w.next_requests(/*now=*/100);               // H0,H1 issued @100
+        assert(w.on_block_received(H(1)) == true);  // H1 arrives, frees a slot
+        w.next_requests(/*now=*/150);               // H2 issued @150
+        // in flight: H0@100, H2@150. timeout 50 at now=155 => only H0 is stale.
+        auto evicted = w.expire(/*now=*/155, /*timeout=*/50);
+        assert(evicted.size() == 1 && evicted[0] == H(0));
+        assert(w.in_flight() == 1);                 // H2 still outstanding
+
+        // A block that arrives AFTER its eviction is reported unsolicited
+        // (no longer in flight) -- caller still applies it; window unaffected.
+        assert(w.on_block_received(H(0)) == false);
+    }
+
     std::cout << "bch block_download window: ALL PASS\n";
     return 0;
 }