nmc(P1 PE): P2P-primary block-relay sink + never-silent-drop submit_block (#223)

Embedded NMC submit path now relays found aux-blocks through a settable
BlockRelayFn sink (host wires it to CoinBroadcaster::submit_block_raw,
decoded at the wiring site, mirroring the BTC on_block_relay seam).
submit_block() no longer claims success unconditionally: an unwired relay
or a 0-peer broadcast surfaces as failure (never-silent-drop, per BTC #162)
while the hex is still cached for get_block_hex(). +3 KATs (relay exact-hex,
no-relay fail, 0-peer fail); existing cache KAT updated to the new contract.
Rides nmc_template_builder_test — no CMake/build.yml change.

Co-authored-by: frstrtr <frstrtr@users.noreply.github.com>

Author: frstrtr

src/impl/nmc/coin/aux_chain_embedded.hpp

@@ -38,6 +38,7 @@
 
 #include <algorithm>
 #include <string>
+#include <functional>
 
 namespace nmc {
 namespace coin {
@@ -118,13 +119,34 @@ class AuxChainEmbedded : public c2pool::merged::IAuxChainBackend
         return get_work_template();
     }
 
+    /// PE submit path: P2P-primary block-relay sink. The host wires this to
+    /// CoinBroadcaster::submit_block_raw (the hex is decoded at the wiring site,
+    /// mirroring the BTC on_block_relay seam). Returns the number of peers the
+    /// block was relayed to (0 => not broadcast). When unset, submit_block()
+    /// REFUSES to claim success (never-silent-drop, per BTC #162).
+    using BlockRelayFn = std::function<size_t(const std::string& block_hex)>;
+    void set_block_relay(BlockRelayFn fn) { m_block_relay = std::move(fn); }
+
     bool submit_block(const std::string& block_hex) override {
-        // Embedded mode: P2P relay handled by CoinBroadcaster. Cache for
-        // get_block_hex() retrieval and log the 80-byte header prefix.
-        LOG_INFO << "[MM:" << m_config.symbol << "] Embedded: block submitted ("
-                 << block_hex.size() / 2 << " bytes)"
-                 << " header=" << block_hex.substr(0, std::min(size_t(160), block_hex.size()));
+        // PE: P2P relay is the primary route. Cache the hex for get_block_hex()
+        // regardless of outcome, but NEVER silently claim success - a found
+        // block that did not reach a peer must surface as a failure so the
+        // caller can fall back (mirrors BTC submitblock never-silent-drop #162).
         m_last_block_hex = block_hex;
+        const size_t nbytes = block_hex.size() / 2;
+        if (!m_block_relay) {
+            LOG_WARNING << "[MM:" << m_config.symbol << "] Embedded: submit_block with NO relay"
+                        << " wired - block NOT broadcast (" << nbytes << " bytes)";
+            return false;
+        }
+        const size_t npeers = m_block_relay(block_hex);
+        if (npeers == 0) {
+            LOG_WARNING << "[MM:" << m_config.symbol << "] Embedded: submit_block reached 0 peers"
+                        << " - block NOT relayed (" << nbytes << " bytes)";
+            return false;
+        }
+        LOG_INFO << "[MM:" << m_config.symbol << "] Embedded: block relayed to " << npeers
+                 << " peer(s) (" << nbytes << " bytes)";
         return true;
     }
 
@@ -166,6 +188,7 @@ class AuxChainEmbedded : public c2pool::merged::IAuxChainBackend
     c2pool::merged::AuxChainConfig     m_config;
     EmbeddedCoinNode                   m_embedded;
     std::string                        m_last_block_hex;  // cached for get_block_hex() after submit
+    BlockRelayFn                       m_block_relay;     // PE: P2P-primary relay sink (unset => never-silent fail)
 };
 
 } // namespace coin

src/impl/nmc/test/nmc_template_builder_test.cpp

@@ -312,11 +312,54 @@ TEST(NmcAuxChainEmbedded, SubmitBlockCachesHexForRetrieval)
 
     EXPECT_EQ(backend.get_block_hex("any"), std::string(""));
     const std::string hex(200, 'a');
-    EXPECT_TRUE(backend.submit_block(hex));
+    // PE never-silent-drop: with no relay wired the block is NOT broadcast, so
+    // submit_block() must report failure - but the hex is still cached for
+    // get_block_hex() diagnostics/retrieval.
+    EXPECT_FALSE(backend.submit_block(hex));
     EXPECT_EQ(backend.get_block_hex("any"), hex);
     // No daemon peers in embedded mode.
     EXPECT_TRUE(backend.getpeerinfo().empty());
 }
 
+// PE submit path: P2P relay is primary. When a relay sink is wired and reaches
+// >=1 peer, submit_block() reports success and the sink receives the exact hex.
+TEST(NmcAuxChainEmbedded, SubmitBlockRelaysExactHexToPeers)
+{
+    HeaderChain chain(params_pinned());
+    Mempool pool;
+    AuxChainEmbedded backend(chain, pool, params_pinned(), nmc_aux_config());
+
+    std::string relayed;
+    backend.set_block_relay([&](const std::string& block_hex) -> size_t {
+        relayed = block_hex;          // capture what the broadcaster would send
+        return 2;                     // pretend 2 peers received it
+    });
+
+    const std::string hex(200, 'b');
+    EXPECT_TRUE(backend.submit_block(hex));   // relayed to >=1 peer => success
+    EXPECT_EQ(relayed, hex);                  // byte-exact hand-off to the sink
+    EXPECT_EQ(backend.get_block_hex("any"), hex);
+}
+
+// PE never-silent-drop: a relay that reaches 0 peers must NOT be reported as a
+// successful broadcast, even though the sink ran (mirrors BTC #162).
+TEST(NmcAuxChainEmbedded, SubmitBlockNeverSilentDropOnZeroPeers)
+{
+    HeaderChain chain(params_pinned());
+    Mempool pool;
+    AuxChainEmbedded backend(chain, pool, params_pinned(), nmc_aux_config());
+
+    bool sink_ran = false;
+    backend.set_block_relay([&](const std::string&) -> size_t {
+        sink_ran = true;
+        return 0;                     // no peers connected
+    });
+
+    const std::string hex(200, 'c');
+    EXPECT_FALSE(backend.submit_block(hex));  // 0 peers => not broadcast
+    EXPECT_TRUE(sink_ran);                    // sink was consulted, not skipped
+    EXPECT_EQ(backend.get_block_hex("any"), hex);  // hex still cached
+}
+
 
 } // namespace