Merge pull request #775 from frstrtr/dash/v36-share-type-phaseA

dash: v36 share type (Phase A) — define + parse, dormant, byte-standardized

Author: frstrtr

src/impl/dash/share.hpp

@@ -70,4 +70,95 @@ struct DashShare : chain::BaseShare<uint256, 16>
     NetService peer_addr;
 };
 
+// ═══════════════════════════════════════════════════════════════════════════
+// DASH v36 share (wire-type 36) — PHASE A: DEFINED + PARSEABLE, DORMANT.
+//
+// Byte-standardized to the cross-coin v36 share shape (the v36-standardize-for-
+// v37 goal: uniform structs). The STANDARDIZED PREFIX (min_header .. message_data)
+// is byte-for-byte the NON-SEGWIT v36 layout — i.e. the BCH v36 MergedMiningShare
+// shape (src/impl/bch/share.hpp), which is the LTC/DGB v36 layout MINUS the
+// Optional(segwit_data) slot. BCH is the reference here (not LTC/DGB directly)
+// because DASH, like BCH, is non-segwit: BCH's SEGWIT_ACTIVATION_VERSION==0 makes
+// is_segwit_activated(36) false, so a non-segwit v36 coin OMITS segwit_data. This
+// is the ESTABLISHED cross-coin convention, NOT a DASH divergence.
+//
+// Field categories (operator 3-bucket / v36-standardize model):
+//   * SHARED / STANDARDIZED (Bucket-2, byte-identical cross-coin): min_header,
+//     prev_hash, coinbase, nonce, pubkey_hash + pubkey_type, subsidy(VarInt),
+//     donation, stale_info, desired_version(VarInt) [THE version-vote], the merged
+//     fields (merged_addresses / merged_coinbase_info / merged_payout_hash — held
+//     EMPTY/INERT since DASH is standalone X11 with no AuxPoW child, exactly as a
+//     non-merged ltc/dgb/bch coin populates them), far_share_hash, max_bits, bits,
+//     timestamp, absheight, abswork(AbsworkV36Format), ref_merkle_link,
+//     last_txout_nonce, hash_link(V36HashLinkType), merkle_link, message_data.
+//   * DASH-SPECIFIC SUFFIX (Bucket-3 / coin-specific, the FLAGGED divergence):
+//     coinbase_payload, payment_amount, packed_payments, coinbase_payload_outer.
+//     DASH masternode / DIP4-CbTx consensus data with NO cross-coin equivalent;
+//     required so Phase C can reconstruct+verify a real DASH coinbase from the
+//     share (a non-merged coin has no analogue). Appended AFTER the standardized
+//     message_data so the ENTIRE standardized prefix stays byte-identical to
+//     bch/ltc/dgb. See the design note + PR body for the review decision.
+//
+// The version-vote (m_desired_version) is what #774's AutoRatchet reads to
+// activate; Phase A only DEFINES this type (dormant, unminted). current_share_version
+// stays 16, so nothing mints a v36 share and the live 1700 accept path is
+// byte-unchanged (Phase C flips activation via the ratchet, NOT here).
+struct DashV36Share : chain::BaseShare<uint256, 36>
+{
+    // ── min_header (SmallBlockHeaderType — coin block header, standardized) ──
+    bitcoin_family::coin::SmallBlockHeaderType m_min_header;
+
+    // ── share_data (STANDARDIZED v36) ──
+    // NOTE: m_prev_hash is inherited from chain::BaseShare<uint256,36>.
+    BaseScript m_coinbase;          // coinbase scriptSig (VarStr)
+    uint32_t m_nonce{0};            // share nonce
+    uint160 m_pubkey_hash;          // v36 address (IntType(160))
+    uint8_t m_pubkey_type{0};       // v36: 0=P2PKH, 1=P2WPKH, 2=P2SH (DASH always 0/P2PKH)
+    uint64_t m_subsidy{0};          // v36: VarInt-encoded
+    uint16_t m_donation{0};         // donation (bps)
+    StaleInfo m_stale_info{StaleInfo::none};
+    uint64_t m_desired_version{36}; // THE version-vote (VarInt)
+
+    // v36 merged-mining address entries — EMPTY/INERT on DASH (no AuxPoW child).
+    std::vector<v36::MergedAddressEntry> m_merged_addresses;
+
+    // ── share_info (non-share_data, STANDARDIZED v36) ──
+    uint256 m_far_share_hash;
+    uint32_t m_max_bits{0};
+    uint32_t m_bits{0};
+    uint32_t m_timestamp{0};
+    uint32_t m_absheight{0};
+    uint128 m_abswork;              // v36: AbsworkV36Format (VarInt low64) on the wire
+
+    // v36 merged-mining coinbase verification — EMPTY/INERT on DASH.
+    std::vector<v36::MergedCoinbaseEntry> m_merged_coinbase_info;
+    uint256 m_merged_payout_hash;   // zero = none (INERT on DASH)
+
+    // ── remaining STANDARDIZED v36 share fields ──
+    v36::MerkleLink m_ref_merkle_link;
+    uint64_t m_last_txout_nonce{0};
+    v36::V36HashLinkType m_hash_link;   // v36: state + extra_data(VarStr) + length(VarInt)
+    v36::MerkleLink m_merkle_link;
+    BaseScript m_message_data;          // v36 messaging hook — EMPTY on DASH in Phase A (Phase B)
+
+    // ── DASH-SPECIFIC SUFFIX (FLAGGED divergence — see struct header) ──
+    BaseScript m_coinbase_payload;          // DIP3/DIP4 CBTX inner (PossiblyNone '', VarStr)
+    uint64_t m_payment_amount{0};           // total masternode payment amount
+    std::vector<PackedPayment> m_packed_payments; // masternode/superblock/platform
+    BaseScript m_coinbase_payload_outer;    // outer coinbase_payload_data (appended to hash_link)
+
+    // ── carried-but-UNSERIALIZED members (v36 wire omits tx_info; kept so a
+    //    future promotion into the live variant matches DashShare's field
+    //    surface for the shared generic-invoke call sites in node.cpp) ──
+    std::vector<uint256> m_new_transaction_hashes;
+    std::vector<uint64_t> m_transaction_hash_refs;
+
+    // Ingestion metadata — not on the wire (parity with DashShare::peer_addr).
+    NetService peer_addr;
+
+    DashV36Share() {}
+    DashV36Share(const uint256& hash, const uint256& prev_hash)
+        : chain::BaseShare<uint256, 36>(hash, prev_hash) {}
+};
+
 } // namespace dash

src/impl/dash/share_chain.hpp

@@ -11,6 +11,7 @@
 #include <sharechain/share.hpp>
 #include <sharechain/sharechain.hpp>
 #include <core/target_utils.hpp>
+#include <core/version_gate.hpp>   // SSOT: core::version_gate::is_v36_active
 
 #include <chrono>
 
@@ -57,6 +58,17 @@ struct DashFormatter
     template <typename StreamType, typename ShareT>
     static void Read(StreamType& is, ShareT* share)
     {
+        // V36 shares (wire-type 36, dash::DashV36Share) use the standardized
+        // cross-coin v36 layout. Compile-time dispatch: the v16 body below is
+        // instantiated ONLY for DashShare (version 16), so it stays byte-
+        // unchanged; the v36 body is instantiated ONLY for DashV36Share.
+        if constexpr (core::version_gate::is_v36_active(ShareT::version))
+        {
+            ReadV36(is, share);
+            return;
+        }
+        else
+        {
         // ── min_header ──
         is >> share->m_min_header;
 
@@ -136,11 +148,19 @@ struct DashFormatter
 
         // ── coinbase_payload (outer) ──
         is >> share->m_coinbase_payload_outer;  // PossiblyNone('', VarStr)
+        } // else (v16)
     }
 
     template <typename StreamType, typename ShareT>
     static void Write(StreamType& os, const ShareT* share)
     {
+        if constexpr (core::version_gate::is_v36_active(ShareT::version))
+        {
+            WriteV36(os, share);
+            return;
+        }
+        else
+        {
         os << share->m_min_header;
         os << share->m_prev_hash;
         os << share->m_coinbase;
@@ -180,6 +200,124 @@ struct DashFormatter
         os << share->m_hash_link;
         os << share->m_merkle_link.m_branch;
         os << share->m_coinbase_payload_outer;
+        } // else (v16)
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // V36 (wire-type 36) read/write — STANDARDIZED cross-coin non-segwit v36
+    // layout (the bch/ltc/dgb MergedMiningShare shape MINUS segwit_data) plus
+    // the DASH-specific suffix. Field ORDER and ENCODINGS mirror the BCH v36
+    // Formatter (src/impl/bch/share.hpp) byte-for-byte for the standardized
+    // prefix; the suffix (coinbase_payload / payment_amount / packed_payments /
+    // coinbase_payload_outer) rides AFTER message_data. Pinned by the byte-
+    // parity + round-trip KATs in test/test_dash_v36_share.cpp.
+    // ═══════════════════════════════════════════════════════════════════════
+    template <typename StreamType, typename ShareT>
+    static void ReadV36(StreamType& is, ShareT* share)
+    {
+        // ── min_header ──
+        is >> share->m_min_header;
+
+        // ── share_data (standardized v36) ──
+        is >> share->m_prev_hash;           // PossiblyNone(0, IntType(256))
+        is >> share->m_coinbase;            // VarStr
+        is >> share->m_nonce;               // uint32
+        is >> share->m_pubkey_hash;         // v36 address: IntType(160)
+        is >> share->m_pubkey_type;         // v36: IntType(8)
+        { uint64_t sub; ::Unserialize(is, VarInt(sub)); share->m_subsidy = sub; } // v36: VarInt
+        is >> share->m_donation;            // uint16
+        { uint8_t si; is >> si; share->m_stale_info = static_cast<dash::StaleInfo>(si); }
+        { uint64_t dv; ::Unserialize(is, VarInt(dv)); share->m_desired_version = dv; } // version-vote
+
+        // NO segwit_data (non-segwit coin — BCH convention).
+
+        // v36 merged_addresses (empty/inert on DASH).
+        is >> share->m_merged_addresses;
+
+        // NO tx_info (only serialized for version < 34).
+
+        is >> share->m_far_share_hash;      // PossiblyNone(0, IntType(256))
+        is >> share->m_max_bits;            // uint32
+        is >> share->m_bits;                // uint32
+        is >> share->m_timestamp;           // uint32
+        is >> share->m_absheight;           // uint32
+        ::Unserialize(is, Using<v36::AbsworkV36Format>(share->m_abswork)); // v36: VarInt low64
+
+        // v36 merged_coinbase_info + merged_payout_hash (empty/zero-inert on DASH).
+        is >> share->m_merged_coinbase_info;
+        is >> share->m_merged_payout_hash;
+
+        // ref_merkle_link (MERKLE_LINK_SMALL — index omitted).
+        { ParamPackStream ps{v36::MERKLE_LINK_SMALL, is}; ::Unserialize(ps, share->m_ref_merkle_link); }
+
+        is >> share->m_last_txout_nonce;    // uint64
+        is >> share->m_hash_link;           // V36HashLinkType
+
+        { ParamPackStream ps{v36::MERKLE_LINK_SMALL, is}; ::Unserialize(ps, share->m_merkle_link); }
+
+        is >> share->m_message_data;        // v36 messaging hook (empty on DASH Phase A)
+
+        // ── DASH-specific suffix (FLAGGED divergence) ──
+        is >> share->m_coinbase_payload;    // PossiblyNone('', VarStr)
+        is >> share->m_payment_amount;      // uint64
+        {
+            uint64_t count;
+            ::Unserialize(is, VarInt(count));
+            if (count > MAX_PAYMENTS_PER_SHARE)
+                throw std::ios_base::failure("packed_payments count exceeds cap");
+            share->m_packed_payments.resize(count);
+            for (uint64_t i = 0; i < count; ++i) {
+                BaseScript payee_bs;
+                is >> payee_bs;
+                share->m_packed_payments[i].m_payee.assign(
+                    payee_bs.m_data.begin(), payee_bs.m_data.end());
+                is >> share->m_packed_payments[i].m_amount;
+            }
+        }
+        is >> share->m_coinbase_payload_outer; // PossiblyNone('', VarStr)
+    }
+
+    template <typename StreamType, typename ShareT>
+    static void WriteV36(StreamType& os, const ShareT* share)
+    {
+        os << share->m_min_header;
+        os << share->m_prev_hash;
+        os << share->m_coinbase;
+        os << share->m_nonce;
+        os << share->m_pubkey_hash;
+        os << share->m_pubkey_type;
+        ::Serialize(os, VarInt(share->m_subsidy));
+        os << share->m_donation;
+        { uint8_t si = static_cast<uint8_t>(share->m_stale_info); os << si; }
+        ::Serialize(os, VarInt(share->m_desired_version));
+        os << share->m_merged_addresses;
+        os << share->m_far_share_hash;
+        os << share->m_max_bits;
+        os << share->m_bits;
+        os << share->m_timestamp;
+        os << share->m_absheight;
+        ::Serialize(os, Using<v36::AbsworkV36Format>(share->m_abswork));
+        os << share->m_merged_coinbase_info;
+        os << share->m_merged_payout_hash;
+        { ParamPackStream ps{v36::MERKLE_LINK_SMALL, os}; ::Serialize(ps, share->m_ref_merkle_link); }
+        os << share->m_last_txout_nonce;
+        os << share->m_hash_link;
+        { ParamPackStream ps{v36::MERKLE_LINK_SMALL, os}; ::Serialize(ps, share->m_merkle_link); }
+        os << share->m_message_data;
+        // ── DASH-specific suffix (FLAGGED divergence) ──
+        os << share->m_coinbase_payload;
+        os << share->m_payment_amount;
+        {
+            uint64_t count = share->m_packed_payments.size();
+            ::Serialize(os, VarInt(count));
+            for (auto& pay : share->m_packed_payments) {
+                BaseScript bs;
+                bs.m_data.assign(pay.m_payee.begin(), pay.m_payee.end());
+                os << bs;
+                os << pay.m_amount;
+            }
+        }
+        os << share->m_coinbase_payload_outer;
     }
 };
 
@@ -188,6 +326,22 @@ struct DashFormatter
 
 using ShareType = chain::ShareVariants<DashFormatter, DashShare>;
 
+// ── PHASE A: v36 share-type dispatch (DORMANT) ───────────────────────────────
+// The live `ShareType` above is DELIBERATELY left as {DashShare} only, so the
+// live accept / mint / store / send paths (node.cpp) stay byte-unchanged and
+// keep compiling — several consume the share via generic-invoke lambdas that
+// call DashShare-concrete helpers (e.g. share_init_verify(const DashShare&) at
+// node.cpp:64). Promoting DashV36Share into the live variant requires guarding
+// those call sites with `if constexpr (std::is_same_v<share_t, DashShare>)`, and
+// is the FIRST wiring step of Phase B/C — NOT Phase A.
+//
+// This SEPARATE variant proves the v36 wire type round-trips through the REAL
+// chain::ShareVariants dispatch machinery (load map keyed by version 36 ->
+// DashV36Share, DashFormatter::ReadV36/WriteV36). It is what the round-trip KAT
+// exercises. Nothing mints a v36 share (current_share_version stays 16), so the
+// type is parseable/mintable-in-principle yet dormant until Phase-C activation.
+using V36ShareType = chain::ShareVariants<DashFormatter, DashV36Share>;
+
 // ── Load share from wire format ──────────────────────────────────────────────
 
 inline ShareType load_share(chain::RawShare& rshare, NetService peer_addr)
@@ -200,6 +354,16 @@ inline ShareType load_share(chain::RawShare& rshare, NetService peer_addr)
     return share;
 }
 
+// PHASE A v36 load helper (dispatch-by-version-36). Mirrors load_share but over
+// the dormant V36ShareType variant; used by the round-trip KAT.
+inline V36ShareType load_v36_share(chain::RawShare& rshare, NetService peer_addr)
+{
+    auto stream = rshare.contents.as_stream();
+    auto share = V36ShareType::load(rshare.type, stream);
+    share.ACTION({ obj->peer_addr = peer_addr; });
+    return share;
+}
+
 // ── ShareHasher ──────────────────────────────────────────────────────────────
 
 struct ShareHasher