bch(finding3): regtest as distinct third net -- serve diff-1 0x207fffff

--pool --regtest previously collapsed to testnet params (anchor@955700,
P2P->.110) and served unwinnable testnet difficulty, so a single CPU
could never win a block. Thread regtest as a third net distinct from
mainnet/testnet:

- asert.hpp: asert_regtest() + bch_pow_limit_regtest() (fPowNoRetargeting,
  fixed target at powLimit nBits 0x207fffff; ASERT bypassed on regtest)
- header_chain.hpp: BCHChainParams::regtest() (P2P 18444, cold-start tip
  seeded so served nbits == 0x207fffff before first P2P regtest block)
- embedded_daemon.hpp / pool_entrypoint.hpp / main_bch.cpp: is_regtest
  dispatch threaded through the --pool entrypoint

GBT-from-local-regtest-BCHN (regtest_block::build_from_gbt) deferred to a
follow-on sub-slice. Consensus-neutral: regtest-only behavior, no mainnet
path change. Fenced to src/impl/bch/ + main_bch.cpp dispatch.

Author: frstrtr

src/c2pool/main_bch.cpp

@@ -642,7 +642,7 @@ int run_pool(const std::string& peer_host, uint16_t peer_port, bool testnet,
 
     try {
         bch::standup_pool_run(ioc, config, anchor_height,
-                              stratum_addr, stratum_port, testnet || regtest);
+                              stratum_addr, stratum_port, testnet || regtest, regtest);
     } catch (const std::exception& e) {
         std::cout << "[pool] FATAL: " << e.what() << "\n";
         return 1;

src/impl/bch/coin/asert.hpp

@@ -74,6 +74,31 @@ inline ASERTParams asert_testnet3() {
     };
 }
 
+inline uint256 bch_pow_limit_regtest() {
+    // BCH regtest powLimit (BCHN CRegTestParams). NOTE: top byte 0x7f does NOT
+    // satisfy CalculateASERT's 32-leading-zero-bits invariant -- which is why
+    // regtest runs with fPowNoRetargeting (ASERT is never invoked on regtest).
+    uint256 v;
+    v.SetHex("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+    return v;
+}
+
+/// BCH regtest difficulty params (BCHN CRegTestParams). fPowNoRetargeting=true,
+/// so the required target is fixed at the powLimit nBits (0x207fffff) for every
+/// block -- ASERT is bypassed (header_chain honours BCHChainParams::no_retargeting).
+/// The anchor here is nominal (genesis) and never feeds CalculateASERT.
+/// allow_min_difficulty mirrors BCHN regtest. (FINDING3: regtest must be its own
+/// net so --pool --regtest serves diff-1 0x207fffff, not the testnet anchor.)
+inline ASERTParams asert_regtest() {
+    return ASERTParams{
+        ASERTAnchor{0, 0x207fffff, 1296688602},  // genesis nBits/time (nominal)
+        2 * 24 * 60 * 60,
+        BCH_TARGET_SPACING,
+        true,
+        bch_pow_limit_regtest(),
+    };
+}
+
 inline ASERTParams asert_testnet4() {
     return ASERTParams{
         ASERTAnchor{16844, 0x1d00ffff, 1605451779},

src/impl/bch/coin/embedded_daemon.hpp

@@ -81,10 +81,12 @@ class EmbeddedDaemon {
     /// Cold-start ctor: floor-anchored ABLA at `anchor_height` (safe default
     /// when no VM300 BCHN pin is available yet). `context`/`config` outlive the
     /// daemon (owned by the binary entrypoint, same contract as coin::Node).
-    EmbeddedDaemon(auto* context, config_t* config, uint32_t anchor_height)
+    EmbeddedDaemon(auto* context, config_t* config, uint32_t anchor_height,
+                   bool is_regtest = false)
         : m_config(config),
-          m_chain(config->m_testnet ? BCHChainParams::testnet()
-                                    : BCHChainParams::mainnet()),
+          m_chain(is_regtest ? BCHChainParams::regtest()
+                             : (config->m_testnet ? BCHChainParams::testnet()
+                                                  : BCHChainParams::mainnet())),
           m_pool(),
           m_embedded(m_chain, m_pool, config->m_testnet),
           m_node(context, config),

src/impl/bch/coin/header_chain.hpp

@@ -150,6 +150,7 @@ struct BCHChainParams {
     uint256     pow_limit;                   // == asert.pow_limit (mirror for check_pow)
     uint256     genesis_hash;                // SHA256d genesis block hash (identification)
     bool        allow_min_difficulty{false}; // == asert.allow_min_difficulty (testnet)
+    bool        no_retargeting{false};       // == BCHN fPowNoRetargeting (regtest)
 
     // Fast-start checkpoint: skip syncing from genesis, start from a recent height.
     // The header chain seeds this checkpoint as if it were the genesis block.
@@ -196,6 +197,25 @@ struct BCHChainParams {
         p.fast_start_checkpoint = Checkpoint{0, p.genesis_hash};
         return p;
     }
+
+    /// BCH regtest params (P2P port 18444). BCHN CRegTestParams:
+    /// fPowNoRetargeting + fPowAllowMinDifficultyBlocks -- difficulty is fixed at
+    /// the genesis nBits 0x207fffff (powLimit), so a single CPU can mine it.
+    /// Genesis is the shared Satoshi regtest genesis. Seeds the cold-start tip so
+    /// served work nbits == 0x207fffff BEFORE the first P2P regtest block arrives
+    /// (FINDING3: --pool --regtest previously collapsed to testnet params and
+    /// served unwinnable testnet difficulty). GBT-from-local-regtest-BCHN
+    /// (regtest_block::build_from_gbt) is a deferred follow-on slice.
+    static BCHChainParams regtest() {
+        BCHChainParams p;
+        p.asert                = asert_regtest();
+        p.pow_limit            = p.asert.pow_limit;
+        p.allow_min_difficulty = p.asert.allow_min_difficulty;
+        p.no_retargeting       = true;
+        p.genesis_hash.SetHex("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206");
+        p.fast_start_checkpoint = Checkpoint{0, p.genesis_hash};
+        return p;
+    }
 };
 
 // ─── PoW Functions ──────────────────────────────────────────────────────────
@@ -705,6 +725,14 @@ class HeaderChain {
     bool validate_difficulty(const BlockHeaderType& header, uint32_t new_height) {
         if (new_height < 2) return true; // genesis + first block
 
+        // Regtest (BCHN fPowNoRetargeting): difficulty never adjusts -- every
+        // block carries the powLimit nBits (0x207fffff). ASERT is bypassed here:
+        // CalculateASERT would assert on the regtest powLimit (top byte 0x7f
+        // violates its 32-leading-zero-bits invariant). The bits/target are
+        // already gated against pow_limit by check_pow at the accept site, so
+        // accept. (FINDING3.)
+        if (m_params.no_retargeting) return true;
+
         // Get tip (the block we're building on).
         auto prev_opt = lookup_header_internal(header.m_previous_block);
         if (!prev_opt) return false;

src/impl/bch/pool_entrypoint.hpp

@@ -85,11 +85,12 @@ inline void standup_pool_run(boost::asio::io_context& ioc,
                              uint32_t anchor_height,
                              const std::string& stratum_addr = "0.0.0.0",
                              uint16_t stratum_port = 0,
-                             bool is_testnet = false)
+                             bool is_testnet = false,
+                             bool is_regtest = false)
 {
     // 1+2: embedded daemon up first -- it owns the work source + RPC fallback
     // the pool node consumes, and is the broadcast sink the node wires into.
-    coin::EmbeddedDaemon<Config> daemon(&ioc, &config, anchor_height);
+    coin::EmbeddedDaemon<Config> daemon(&ioc, &config, anchor_height, is_regtest);
     daemon.run();
 
     // 3: the pool node (sharechain, LevelDB, P2P, Stratum).