nmc(P0): embedded merge-mining foundation leaf — structure-only coin tree (#175)

Lay down src/impl/nmc/coin as the P0 structural foundation for embedded
merge-mined Namecoin under a BTC parent (DOGE-under-LTC analog):
header_chain.hpp (AuxPow header interface, parent-powhash path), block.hpp,
transaction.{hpp,cpp}, coin_smoke.cpp TU, plus CMake wiring (nmc_coin lib).

Fences (per integrator ACK msgid 5823428726...):
- btc tree READ-ONLY: NMC consumes src/impl/btc public header types only.
- AuxPow merkle-branch proof walk + block-validation = P0-DEFER stubs.
- vector<AuxChain> stays nmc-local; no lift into bitcoin_family/src/core.
- chain_id / auxpow_activation_height (cited ~19200) / genesis kept as -1
  TO-CONFIRM sentinels, NOT compiled constants — pinning gated on VMID 219
  nmc-testnet landing (chainparams + namecoind ground-truth).

nmc_coin smoke target builds clean (cmake --build --target nmc_coin, exit 0).

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

Author: frstrtr

src/impl/CMakeLists.txt

@@ -2,3 +2,4 @@ add_subdirectory(ltc)
 add_subdirectory(btc)
 add_subdirectory(dgb)
 add_subdirectory(dash)
+add_subdirectory(nmc)

src/impl/nmc/CMakeLists.txt

@@ -0,0 +1,3 @@
+# NMC (embedded merge-mined Namecoin) — P0 structural leaf.
+# Only the coin tree exists at P0. node/stratum/share layers come later.
+add_subdirectory(coin)

src/impl/nmc/coin/CMakeLists.txt

@@ -0,0 +1,15 @@
+# NMC coin tree — P0 structural leaf.
+# Mirror of src/impl/btc/coin/CMakeLists.txt (header-only interface files +
+# a translation unit that forces them to compile). STRUCTURE-only: no node /
+# rpc / p2p layers yet.
+
+set(nmc_coin_interface
+    transaction.hpp transaction.cpp
+    block.hpp
+    header_chain.hpp
+    coin_smoke.cpp
+)
+
+add_library(nmc_coin ${nmc_coin_interface})
+
+target_link_libraries(nmc_coin core nlohmann_json::nlohmann_json)

src/impl/nmc/coin/block.hpp

@@ -0,0 +1,127 @@
+#pragma once
+
+// NMC (Namecoin) block / header primitives.
+//
+// Mirror of src/impl/btc/coin/block.hpp. Namecoin is a Bitcoin (SHA256d) fork;
+// its plain block header layout is byte-identical to Bitcoin's. Re-homed into
+// namespace nmc::coin. No btc header is modified.
+//
+// P0-DEFER: Namecoin blocks are AUX-POW capable. The merge-mined parent-chain
+// proof (CAuxPow: parent coinbase tx + coinbase merkle branch + parent block
+// header) is NOT modelled here. The plain header below is the foundation leaf;
+// the AuxPow attachment is a later leaf — see header_chain.hpp AuxPowStub.
+
+#include "transaction.hpp"
+
+#include <core/uint256.hpp>
+#include <core/pack_types.hpp>
+#include <core/netaddress.hpp>
+
+namespace nmc
+{
+
+namespace coin
+{
+
+struct SmallBlockHeaderType
+{
+    uint64_t m_version {};
+    uint256 m_previous_block{};
+    uint32_t m_timestamp{};
+    uint32_t m_bits{};
+    uint32_t m_nonce{};
+
+    C2POOL_SERIALIZE_METHODS(SmallBlockHeaderType) { READWRITE(VarInt(obj.m_version), obj.m_previous_block, obj.m_timestamp, obj.m_bits, obj.m_nonce); }
+
+    SmallBlockHeaderType() {}
+
+    void SetNull()
+    {
+        m_version = 0;
+        m_previous_block.SetNull();
+        m_timestamp = 0;
+        m_bits = 0;
+        m_nonce = 0;
+    }
+
+    bool IsNull() const
+    {
+        return (m_bits == 0);
+    }
+};
+
+struct BlockHeaderType : SmallBlockHeaderType
+{
+    uint256 m_merkle_root;
+
+    // Full block header uses fixed 4-byte int32 version (not VarInt like SmallBlockHeaderType)
+    template<typename Stream>
+    void Serialize(Stream& s) const {
+        uint32_t version32 = static_cast<uint32_t>(m_version);
+        ::Serialize(s, version32);
+        ::Serialize(s, m_previous_block);
+        ::Serialize(s, m_merkle_root);
+        ::Serialize(s, m_timestamp);
+        ::Serialize(s, m_bits);
+        ::Serialize(s, m_nonce);
+    }
+    template<typename Stream>
+    void Unserialize(Stream& s) {
+        uint32_t version32;
+        ::Unserialize(s, version32);
+        m_version = version32;
+        ::Unserialize(s, m_previous_block);
+        ::Unserialize(s, m_merkle_root);
+        ::Unserialize(s, m_timestamp);
+        ::Unserialize(s, m_bits);
+        ::Unserialize(s, m_nonce);
+    }
+
+    BlockHeaderType() : SmallBlockHeaderType() { }
+
+    void SetNull()
+    {
+        SmallBlockHeaderType::SetNull();
+        m_merkle_root.SetNull();
+    }
+
+    bool IsNull() const
+    {
+        return (m_bits == 0);
+    }
+
+};
+
+struct BlockType : BlockHeaderType
+{
+	std::vector<MutableTransaction> m_txs;
+
+    template <typename Stream>
+    void Serialize(Stream& s) const {
+        BlockHeaderType::Serialize(s);
+        ::Serialize(s, TX_WITH_WITNESS(m_txs));
+    }
+
+    template <typename Stream>
+    void Unserialize(Stream& s) {
+        BlockHeaderType::Unserialize(s);
+        ::Unserialize(s, TX_WITH_WITNESS(m_txs));
+    }
+
+    BlockType() : BlockHeaderType() { }
+
+    void SetNull()
+    {
+        BlockHeaderType::SetNull();
+        m_txs.clear();
+    }
+
+    bool IsNull() const
+    {
+        return BlockHeaderType::IsNull();
+    }
+};
+
+} // namespace coin
+
+} // namespace nmc

src/impl/nmc/coin/coin_smoke.cpp

@@ -0,0 +1,41 @@
+// NMC coin P0 structural-leaf smoke translation unit.
+//
+// Header-only NMC coin types (block.hpp, header_chain.hpp) are otherwise never
+// instantiated in a .cpp, so they would not be compile-checked by the build.
+// This TU forces instantiation of the P0 structural leaf so CMake's nmc_coin
+// target actually compiles header_chain.hpp (and its AuxPow / HeaderChain
+// skeleton). It does NOT perform any validation — consistent with the P0 fence.
+
+#include "header_chain.hpp"
+#include "block.hpp"
+
+namespace nmc {
+namespace coin {
+
+// Force template/inline instantiation of the structural leaf.
+void nmc_coin_p0_smoke()
+{
+    NMCChainParams params = NMCChainParams::mainnet();
+    HeaderChain chain(params);
+    (void)chain.init();
+    (void)chain.height();
+    (void)chain.size();
+
+    BlockHeaderType header;
+    header.SetNull();
+    (void)block_hash(header);
+    (void)pow_hash(header);
+
+    AuxPow auxpow;
+    auxpow.SetNull();
+    // P0-DEFER stub must report NOT_IMPLEMENTED_P0.
+    (void)auxpow.check_proof(uint256{}, params.aux_chain_id);
+
+    AuxChain aux_slot;
+    std::vector<AuxChain> aux_chains; // nmc-local list (fence #4)
+    aux_chains.push_back(aux_slot);
+    (void)aux_chains;
+}
+
+} // namespace coin
+} // namespace nmc