Dash Phase C-PAY: block-replay test harness Day 1 — dumper + 66 fixtures

Phase 1 of the block-replay test harness per
frstrtr/the/docs/c2pool-dash-block-replay-test-harness.md. Day 2 will
add the test target that consumes these fixtures.

The motivation is to shift consensus-correctness validation from
soak-driven (days, stochastic) to replay-driven (minutes, deterministic).
Bug 15 (DIP-0027 platform reward) sat on-chain for ~7 months because
soak-MISMATCH only fires when an MN identity mismatch doesn't fire
first; a pure-replay harness would have failed on iteration 1.

Changes:
- src/impl/dash/coin/rpc.{hpp,cpp}: expose getblockhash(int height)
- src/impl/dash/coin/block_dumper.hpp: BlockDumper that walks N heights,
  writes one JSON fixture per block (idempotent — skips existing files
  on re-run). Plus canonical_fixture_heights(tip) producing the
  curated coverage set (V20 boundary, MN_RR boundary, superblocks,
  halvings, known-Bug anchors, recent tip).
- src/impl/dash/main_dash.cpp: --dump-blocks DIR + --dump-blocks-heights
  CSV one-shot CLI mirroring the --dump-mn-snapshot flow.
- test/fixtures/dash_blocks/: 66 deduplicated JSON fixtures
  (~17 MB) spanning h=1,987,775..2,473,133. Includes the Bug 12/13/14/15
  diagnostic anchors. Generated by:
    c2pool-dash --dump-blocks test/fixtures/dash_blocks \
                --dashd-rpc 192.168.86.24:9998:...

Each fixture file contains:
  height, block_hash, block_hex (verbosity=0 raw),
  block_verbose (verbosity=2 — decoded coinbase + tx details +
  cb_tx extraPayload fields for ground-truth assertions).

Day 2 will add test/test_dash_block_replay.cpp with per-block
assertions on platform reward, MN payment, expected payee, SML root,
quorums root, credit-pool balance, and subsidy split sum.

Author: frstrtr

src/impl/dash/coin/block_dumper.hpp

@@ -0,0 +1,177 @@
+#pragma once
+
+/// Block-replay regression test harness — Phase 1 dumper.
+///
+/// Connects to a trusted dashd via JSON-RPC and dumps N blocks as
+/// JSON fixtures to disk. Each fixture file captures everything the
+/// replay test needs to assert bit-exact formula correctness:
+///   - block hex (verbosity=0 raw)
+///   - getblock verbosity=2 JSON (decoded coinbase outputs, tx details,
+///     cb_tx extraPayload fields)
+///   - height + block hash
+///
+/// One file per block: `<out_dir>/h<HEIGHT>.json`. Pre-existing files
+/// are skipped (idempotent — safe to re-run after RPC outage).
+///
+/// Design doc: frstrtr/the/docs/c2pool-dash-block-replay-test-harness.md
+///
+/// Usage from main_dash:
+///   dash::coin::BlockDumper dumper{rpc, out_dir, heights};
+///   dumper.run();   // walks heights, writes files, logs progress
+
+#include <impl/dash/coin/rpc.hpp>
+#include <core/log.hpp>
+#include <core/uint256.hpp>
+
+#include <nlohmann/json.hpp>
+
+#include <filesystem>
+#include <fstream>
+#include <string>
+#include <vector>
+
+namespace dash {
+namespace coin {
+
+struct BlockDumper {
+    NodeRPC&             rpc;
+    std::string          out_dir;
+    std::vector<int>     heights;   // explicit list — caller picks coverage
+
+    // Returns number of blocks successfully written. Skips heights that
+    // already have a file on disk (re-runnable after failure).
+    int run()
+    {
+        std::filesystem::create_directories(out_dir);
+
+        int written = 0;
+        int skipped = 0;
+        int failed  = 0;
+        for (size_t i = 0; i < heights.size(); ++i) {
+            int h = heights[i];
+            std::string path = out_dir + "/h" + std::to_string(h) + ".json";
+
+            if (std::filesystem::exists(path)) {
+                ++skipped;
+                continue;
+            }
+
+            try {
+                nlohmann::json hash_resp = rpc.getblockhash(h);
+                if (!hash_resp.is_string()) {
+                    LOG_WARNING << "[BLOCK-DUMP] h=" << h
+                                << " getblockhash returned non-string";
+                    ++failed;
+                    continue;
+                }
+                std::string hash_hex = hash_resp.get<std::string>();
+                uint256 hash;
+                hash.SetHex(hash_hex);
+
+                // Two RPC calls: verbosity=0 gives raw hex (for c2pool's
+                // parser), verbosity=2 gives the decoded JSON (for ground
+                // truth: coinbase vouts, cb_tx fields, payee addresses).
+                nlohmann::json block_hex     = rpc.getblock(hash, 0);
+                nlohmann::json block_verbose = rpc.getblock(hash, 2);
+
+                nlohmann::json fixture = {
+                    {"height",        h},
+                    {"block_hash",    hash_hex},
+                    {"block_hex",     block_hex},
+                    {"block_verbose", block_verbose},
+                };
+
+                std::ofstream out(path);
+                out << fixture.dump(2);
+                ++written;
+
+                if ((written + skipped) % 10 == 0 || i + 1 == heights.size()) {
+                    LOG_INFO << "[BLOCK-DUMP] progress: "
+                             << (i + 1) << "/" << heights.size()
+                             << " (written=" << written
+                             << " skipped=" << skipped
+                             << " failed=" << failed << ")";
+                }
+            } catch (const std::exception& e) {
+                LOG_WARNING << "[BLOCK-DUMP] h=" << h
+                            << " failed: " << e.what();
+                ++failed;
+            }
+        }
+
+        LOG_INFO << "[BLOCK-DUMP] complete: written=" << written
+                 << " skipped=" << skipped
+                 << " failed=" << failed
+                 << " out_dir=" << out_dir;
+        return written;
+    }
+};
+
+/// Produce the canonical 100-block fixture selection from the design doc.
+/// Heights chosen to span: V20 boundary, MN_RR boundary, superblocks,
+/// halvings, broad recent regression coverage, recent tip.
+///
+/// `tip_height` should be the current chain tip (from getblockchaininfo)
+/// — the "recent tip" portion is anchored to it. Pass `recent_tip=true`
+/// to include tip-relative heights; `false` if tip blocks aren't desired
+/// (e.g. for offline replay against an older snapshot).
+inline std::vector<int> canonical_fixture_heights(int tip_height)
+{
+    std::vector<int> hs;
+
+    // 5 blocks straddling V20 activation (h=1,987,776 mainnet)
+    for (int delta : {-1, 0, 1, 24, 224}) hs.push_back(1'987'776 + delta);
+
+    // 5 blocks straddling MN_RR activation (h=2,128,896 — Bug 15 boundary)
+    for (int delta : {-1, 0, 1, 4, 104}) hs.push_back(2'128'896 + delta);
+
+    // 5 superblock heights post-MN_RR (cycle=16,616)
+    for (int n : {129, 130, 131, 140, 145}) hs.push_back(n * 16'616);
+
+    // 5 halving-boundary blocks near recent tip
+    for (int n : {10, 11, 12}) {
+        int h = n * 210'240;
+        if (h < tip_height) {
+            hs.push_back(h - 1);
+            hs.push_back(h);
+        }
+    }
+
+    // 20 random-spread blocks across post-MN_RR mainnet
+    for (int i = 0; i < 20; ++i) {
+        hs.push_back(2'200'000 + i * 11'000);  // every ~11k blocks
+    }
+
+    // 20 recent-tip blocks (last 20 if tip is set)
+    if (tip_height > 0) {
+        for (int i = 20; i > 0; --i) hs.push_back(tip_height - i);
+    }
+
+    // 20 blocks at known interesting heights — Bug discovery anchors
+    // (Bug 15 caught here, plus padding for future-Bug anchors)
+    for (int h : {
+        2'460'249,   // first DMN snapshot block (mn_snapshot.hpp pin)
+        2'463'018,   // Bug 12 PoSe-ban height
+        2'462'994,   // Bug 13 CProUpServTx parse failure block
+        2'465'346,   // Bug 14 implicit-revive height
+        2'465'862,   // Bug 14 snapshot pin
+        2'470'904,   // Bug 15 platform-reward verification block
+        2'470'890,   // Bug-15 recovery snapshot block
+    }) {
+        hs.push_back(h);
+    }
+
+    // De-dup + sort + drop out-of-range
+    std::sort(hs.begin(), hs.end());
+    hs.erase(std::unique(hs.begin(), hs.end()), hs.end());
+    if (tip_height > 0) {
+        hs.erase(std::remove_if(hs.begin(), hs.end(),
+                                [tip_height](int h) { return h > tip_height; }),
+                 hs.end());
+    }
+
+    return hs;
+}
+
+} // namespace coin
+} // namespace dash

src/impl/dash/coin/rpc.cpp

@@ -220,6 +220,11 @@ nlohmann::json NodeRPC::getblock(const uint256& blockhash, int verbosity)
     return call_method("getblock", {blockhash, verbosity});
 }
 
+nlohmann::json NodeRPC::getblockhash(int height)
+{
+    return call_method("getblockhash", {height});
+}
+
 // ── Dash GBT parsing ─────────────────────────────────────────────────────────
 
 void NodeRPC::parse_payments(const nlohmann::json& gbt, DashWorkData& out)

src/impl/dash/coin/rpc.hpp

@@ -60,6 +60,8 @@ class NodeRPC : public jsonrpccxx::IClientConnector
     nlohmann::json getmininginfo();
     nlohmann::json getblockheader(const uint256& header, bool verbose = true);
     nlohmann::json getblock(const uint256& blockhash, int verbosity = 1);
+    // Maps height → block hash. Used by block_dumper for the replay harness.
+    nlohmann::json getblockhash(int height);
 
     // Fetch + parse GBT → DashWorkData (Dash-specific field extraction).
     DashWorkData getwork();

src/impl/dash/main_dash.cpp

@@ -33,6 +33,7 @@
 #include <impl/dash/coin/mn_state_db.hpp>
 #include <impl/dash/coin/mn_snapshot.hpp>
 #include <impl/dash/coin/mn_snapshot_rpc.hpp>
+#include <impl/dash/coin/block_dumper.hpp>
 #include <impl/dash/coin/mn_state_machine.hpp>
 #include <impl/dash/coin/mempool.hpp>
 #include <impl/dash/coin/subsidy.hpp>
@@ -190,6 +191,8 @@ int main(int argc, char* argv[])
     std::string gbt_source = "auto";
     std::string dash_mn_snapshot_path;     // --dash-mn-snapshot operator override
     std::string dump_mn_snapshot_output;   // --dump-mn-snapshot one-shot dumper
+    std::string dump_blocks_out_dir;       // --dump-blocks one-shot fixture dump
+    std::string dump_blocks_heights;       // optional CSV; empty → canonical 100
     uint16_t    stratum_port   = 0;       // 0 = disabled; canonical Dash p2pool stratum port is 7903
     std::string mining_address;           // required when stratum+rpc are wired
     double      share_difficulty_default = 0.001;  // vardiff lands later
@@ -241,6 +244,12 @@ int main(int argc, char* argv[])
         else if (arg == "--dump-mn-snapshot" && i + 1 < argc) {
             dump_mn_snapshot_output = argv[++i];
         }
+        else if (arg == "--dump-blocks" && i + 1 < argc) {
+            dump_blocks_out_dir = argv[++i];
+        }
+        else if (arg == "--dump-blocks-heights" && i + 1 < argc) {
+            dump_blocks_heights = argv[++i];
+        }
         else if (arg == "--dashd" && i + 1 < argc) {
             std::string addr = argv[++i];
             auto colon = addr.find(':');
@@ -473,6 +482,85 @@ int main(int argc, char* argv[])
         return exit_code;
     }
 
+    // ── --dump-blocks one-shot path (block-replay test harness, Phase 1) ──
+    // Walks N heights via dashd RPC, writes one JSON fixture per block to
+    // out_dir. Heights either explicit via --dump-blocks-heights "H1,H2,..."
+    // or the canonical 100-block selection from block_dumper.hpp.
+    //
+    // Usage:
+    //   c2pool-dash --dump-blocks test/fixtures/dash_blocks/ \
+    //               --dashd-rpc HOST:PORT:USER:PASS
+    //   c2pool-dash --dump-blocks test/fixtures/dash_blocks/ \
+    //               --dump-blocks-heights 2470904,2470905 \
+    //               --dashd-rpc HOST:PORT:USER:PASS
+    //
+    // Design doc: frstrtr/the/docs/c2pool-dash-block-replay-test-harness.md
+    if (!dump_blocks_out_dir.empty()) {
+        if (dashd_rpc_host.empty()) {
+            std::cerr << "[--dump-blocks] requires --dashd-rpc to be set"
+                      << std::endl;
+            return 1;
+        }
+        boost::asio::io_context dump_ioc;
+        dash::interfaces::Node dump_iface;
+        auto dump_rpc = std::make_unique<dash::coin::NodeRPC>(
+            &dump_ioc, &dump_iface, testnet);
+        boost::asio::post(dump_ioc, [&]() {
+            NetService rpc_addr(dashd_rpc_host + ":" + std::to_string(dashd_rpc_port));
+            dump_rpc->connect(rpc_addr, dashd_rpc_userpass);
+        });
+        int exit_code = 0;
+        auto dump_timer = std::make_shared<boost::asio::steady_timer>(
+            dump_ioc, std::chrono::seconds(5));
+        dump_timer->async_wait(
+            [&, dump_timer](const boost::system::error_code& ec) {
+            if (ec) return;
+            if (!dump_rpc || !dump_rpc->is_connected()) {
+                std::cerr << "[--dump-blocks] RPC not connected after 5s — aborting"
+                          << std::endl;
+                exit_code = 2;
+                dump_ioc.stop();
+                return;
+            }
+
+            // Build heights list
+            std::vector<int> heights;
+            if (!dump_blocks_heights.empty()) {
+                std::string s = dump_blocks_heights;
+                size_t pos = 0;
+                while (pos < s.size()) {
+                    size_t comma = s.find(',', pos);
+                    std::string tok = s.substr(pos, comma - pos);
+                    if (!tok.empty()) heights.push_back(std::stoi(tok));
+                    if (comma == std::string::npos) break;
+                    pos = comma + 1;
+                }
+            } else {
+                int tip = 0;
+                try {
+                    auto info = dump_rpc->getblockchaininfo();
+                    tip = info.value("blocks", 0);
+                } catch (...) {
+                    std::cerr << "[--dump-blocks] getblockchaininfo failed" << std::endl;
+                    exit_code = 3;
+                    dump_ioc.stop();
+                    return;
+                }
+                heights = dash::coin::canonical_fixture_heights(tip);
+                std::cout << "[--dump-blocks] using canonical fixture set: "
+                          << heights.size() << " heights, tip=" << tip << std::endl;
+            }
+
+            dash::coin::BlockDumper dumper{*dump_rpc, dump_blocks_out_dir, std::move(heights)};
+            int written = dumper.run();
+            std::cout << "[--dump-blocks] OK — wrote " << written
+                      << " new fixture(s) to " << dump_blocks_out_dir << std::endl;
+            dump_ioc.stop();
+        });
+        dump_ioc.run();
+        return exit_code;
+    }
+
     // X11 self-test
     {
         unsigned char zeros[80] = {};