bch(g3a): populate embedded mempool from BCHN GBT for populated won blocks

The embedded daemon built coinbase-only templates (nTx=1) on regtest and any
RPC-primary deploy: loose BCHN-mempool txs never reach the embedded P2P relay,
so build_template selected from an empty m_pool. Two fenced fixes:

1. EmbeddedDaemon::sync_mempool_from_rpc() (run()-startup): feed the BCHN GBT
   tx set -- the same set NodeRPC::getwork() consumes -- into m_pool. No-op when
   no external RPC is bound; regtest skips the mainnet/testnet anchor (is_regtest
   stored as a member). One-shot known limitation; per-tip refresh is a tracked
   non-blocking follow-up.

2. Mempool::add_tx_with_known_fee() + GBT per-tx fee passthrough (fee_known=true)
   so get_sorted_txs_with_fees() selects GBT txs into the template and
   coinbasevalue stays accurate.

Proven on live regtest BCHN: won block @h326 nTx=7 (6 mempool + coinbase),
1539-byte relayed body, both broadcaster legs fire (p2p sent, rpc ok, tip
325->326). Fence: src/impl/bch only; no p2pool-merged-v36 surface; external-RPC
fallback preserved.

Author: frstrtr

src/impl/bch/coin/embedded_daemon.hpp

@@ -91,7 +91,7 @@ class EmbeddedDaemon {
           m_embedded(m_chain, m_pool, config->m_testnet),
           m_node(context, config),
           m_abla(config->m_testnet, anchor_height, m_chain),
-          m_connector(m_chain, m_pool) {}
+          m_connector(m_chain, m_pool) { m_regtest = is_regtest; }
 
     EmbeddedDaemon(const EmbeddedDaemon&) = delete;
     EmbeddedDaemon& operator=(const EmbeddedDaemon&) = delete;
@@ -107,12 +107,58 @@ class EmbeddedDaemon {
         wire_chain_ingest();          // new_headers --> HeaderChain (advances synced height)
         pin_cold_start_anchor();      // operator-APPROVED VM300 anchor (decisions@ 2026-06-18); floor-equivalent
         const bool p2p_up = maybe_start_p2p(); // arm won-block P2P relay leg + connector re-request sink (gated on configured peer)
+        sync_mempool_from_rpc();      // RPC-fallback: BCHN loose-mempool txs never reach embedded P2P -> fill m_pool so populated templates (nTx>1) are built
         LOG_INFO << "[EMB-BCH] embedded daemon up: embedded-primary work source,"
                  << " external BCHN-RPC fallback retained, ABLA loop closed"
                  << " (cold-start anchor pinned @" << BchnAnchorRecord::height << "),"
                  << " P2P relay leg " << (p2p_up ? "LIVE" : "OFF (no peer configured -> RPC-only)") << ".";
     }
 
+    /// Populate the embedded mempool from the external BCHN GBT (RPC-fallback
+    /// path). On regtest -- and any RPC-primary deploy -- loose transactions
+    /// live in BCHN's mempool and never reach the embedded P2P relay, so the
+    /// template builder selects from an empty m_pool and every won block is
+    /// coinbase-only (nTx=1). BCHN GBT already returns the CTOR-ordered,
+    /// fee-annotated, consensus-valid tx set -- the SAME set NodeRPC::getwork()
+    /// consumes for the external-RPC work path -- so we hand those to m_pool and
+    /// build_template selects them unchanged. No-op when no external RPC is bound
+    /// (a pure embedded-P2P deploy keeps its own relayed mempool).
+    /// KNOWN LIMITATION: one-shot at run()-startup; per-tip/periodic refresh is a
+    /// tracked production-standup follow-up (fenced, non-blocking for G3a).
+    /// p2pool-merged-v36 surface: NONE -- local mempool population only.
+    std::size_t sync_mempool_from_rpc() {
+        auto* r = m_node.rpc();
+        if (!r) return 0;             // pure embedded-P2P deploy -> no RPC fill
+        std::size_t added = 0;
+        try {
+            auto wd = r->getwork();   // GBT-derived; m_txs unpacked, witness-free
+            const auto& jtx = (wd.m_data.is_object() && wd.m_data.contains("transactions")
+                               && wd.m_data["transactions"].is_array())
+                                  ? wd.m_data["transactions"]
+                                  : nlohmann::json::array();
+            for (std::size_t i = 0; i < wd.m_txs.size(); ++i) {
+                MutableTransaction mtx(wd.m_txs[i]);
+                bool ok = false;
+                if (i < jtx.size() && jtx[i].is_object()
+                        && jtx[i].contains("fee") && jtx[i]["fee"].is_number()) {
+                    // Authoritative per-tx fee from BCHN GBT -> fee_known=true so
+                    // get_sorted_txs_with_fees() selects it into the template.
+                    ok = m_pool.add_tx_with_known_fee(
+                             mtx, static_cast<uint64_t>(jtx[i]["fee"].template get<int64_t>()));
+                } else {
+                    ok = m_pool.add_tx(mtx);  // no fee field -> UTXO/feeless fallback
+                }
+                if (ok) ++added;
+            }
+            LOG_INFO << "[EMB-BCH] mempool RPC-sync: +" << added
+                     << " txs from BCHN GBT (m_pool size=" << m_pool.size() << ")";
+        } catch (const std::exception& e) {
+            LOG_WARNING << "[EMB-BCH] mempool RPC-sync skipped (RPC fallback): "
+                        << e.what();
+        }
+        return added;
+    }
+
     /// READ-ONLY IBD evidence harness entry (drives the --ibd run-loop in
     /// main_bch.cpp). Brings up ONLY the network-free chain + the P2P front-end
     /// pointed at a single BCHN peer (VM300 bchn-bch .110:8333), with the
@@ -369,6 +415,13 @@ class EmbeddedDaemon {
     /// p2pool-merged-v36 surface (ABLA is BCH embedded-internal).
     void pin_cold_start_anchor() {
         using Rec = BchnAnchorRecord;
+        if (m_regtest) {
+            // Regtest has no mainnet/testnet BCHN anchor; the @955700 record is
+            // meaningless here. ABLA stays at its floor anchor; the chain syncs
+            // from the regtest genesis. Skipping the pin keeps regtest correct.
+            LOG_INFO << "[EMB-BCH] cold-start anchor SKIPPED (regtest: floor ABLA, genesis-rooted chain).";
+            return;
+        }
         apply_bchn_anchor(Rec::height, Rec::state(m_config->m_testnet));
         const uint64_t pinned = m_abla.tracker().budget_for_tip(Rec::height);
         if (Rec::is_floor())
@@ -496,6 +549,7 @@ class EmbeddedDaemon {
     }
 
 private:
+    bool             m_regtest = false; // regtest 3rd-net: skip mainnet/testnet anchor + drive RPC mempool sync
     config_t*        m_config;   // not owned (binary entrypoint owns it)
     HeaderChain      m_chain;    // before m_embedded + m_abla: their refs bind here
     Mempool          m_pool;     // before m_embedded

src/impl/bch/coin/mempool.hpp

@@ -172,6 +172,42 @@ class Mempool {
         return true;
     }
 
+    /// Add a transaction with a KNOWN fee supplied by an authoritative source
+    /// (BCHN GBT transactions[].fee). Used by the embedded-daemon RPC mempool
+    /// sync: BCHN already validated the tx and computed its exact fee, so we set
+    /// fee_known=true and index it for template selection. Without this the tx
+    /// lands with fee_known=false and get_sorted_txs_with_fees() excludes it
+    /// (empty template -> coinbase-only won blocks, nTx=1). Fee accuracy matches
+    /// p2pool, which sources fees from the same daemon GBT.
+    bool add_tx_with_known_fee(const MutableTransaction& tx, uint64_t fee) {
+        uint256 txid = compute_txid(tx);
+        std::lock_guard<std::mutex> lock(m_mutex);
+        if (m_pool.count(txid))
+            return false;
+        MempoolEntry entry;
+        entry.tx         = tx;
+        entry.txid       = txid;
+        entry.byte_size  = compute_tx_byte_size(tx);
+        entry.time_added = std::time(nullptr);
+        entry.fee        = fee;
+        entry.fee_known  = true;
+        int evicted = 0;
+        while (m_total_bytes + entry.byte_size > m_max_bytes && !m_time_index.empty()) {
+            auto oldest = m_time_index.begin();
+            evict_one_locked(oldest->second);
+            ++evicted;
+        }
+        m_pool[txid] = std::move(entry);
+        auto& stored = m_pool[txid];
+        m_time_index.emplace(stored.time_added, txid);
+        m_total_bytes += stored.byte_size;
+        for (const auto& vin : stored.tx.vin) {
+            m_spent_outputs[std::make_pair(vin.prevout.hash, vin.prevout.index)] = txid;
+        }
+        m_feerate_index.emplace(stored.feerate(), txid);
+        return true;
+    }
+
     /// Remove a single transaction by txid.
     void remove_tx(const uint256& txid) {
         std::lock_guard<std::mutex> lock(m_mutex);