dash(G1): deterministic equal-feerate tx selection for byte-parity

Block-template tx ordering was the next non-deterministic seam after the
curtime seam (#622): get_sorted_txs_with_fees streamed a
std::multimap<double,uint256>, so equal-feerate txs kept mempool
INSERTION order — node-dependent, breaking G1 byte-parity of the
embedded-GBT template projection against the p2pool-dash/dashcore oracle.

Replace the index with a FeeKey set sorting feerate-desc then txid-asc,
matching dashcore CompareTxMemPoolEntryByAncestorFee (GetHash tiebreak).
Selection is now byte-reproducible regardless of arrival order.

Fenced to src/impl/dash/coin/mempool.hpp + test. No shared/other-coin
tree, no consensus-value change (same txs, deterministic order). KAT
pins equal-feerate ties resolve txid-ascending, insertion-independent.

Author: frstrtr

src/impl/dash/coin/mempool.hpp

@@ -49,6 +49,7 @@
 #include <cstdint>
 #include <ctime>
 #include <map>
+#include <set>
 #include <mutex>
 #include <optional>
 #include <utility>
@@ -72,6 +73,21 @@ struct MempoolEntry {
     }
 };
 
+/// Deterministic block-template selection key. Sorts highest-feerate
+/// first; ties broken by txid ascending. This makes
+/// get_sorted_txs_with_fees byte-reproducible across nodes/runs
+/// (equal-feerate txs no longer depend on mempool insertion order) and
+/// matches dashcore BlockAssembler ordering
+/// (CompareTxMemPoolEntryByAncestorFee breaks feerate ties by GetHash()).
+struct FeeKey {
+    double  feerate;
+    uint256 txid;
+    bool operator<(const FeeKey& o) const {
+        if (feerate != o.feerate) return feerate > o.feerate; // higher feerate first
+        return txid < o.txid;                                 // txid asc tiebreak (oracle-conformant)
+    }
+};
+
 class Mempool {
 public:
     static constexpr size_t DEFAULT_MAX_BYTES   = 300ULL * 1024 * 1024;
@@ -139,7 +155,7 @@ class Mempool {
         // recompute_unknown_fees() resolves them after a UTXO update.
         // Uses negative feerate as the multimap key so begin() = best.
         if (stored.fee_known) {
-            m_feerate_index.emplace(stored.feerate_satvb(), txid);
+            m_feerate_index.insert(FeeKey{stored.feerate_satvb(), txid});
         }
 
         // Periodic stats — every 100 entries + first 5 + every eviction.
@@ -243,7 +259,7 @@ class Mempool {
         for (auto& [txid, entry] : m_pool) {
             if (entry.fee_known) continue;
             if (compute_fee_locked(entry, utxo)) {
-                m_feerate_index.emplace(entry.feerate_satvb(), txid);
+                m_feerate_index.insert(FeeKey{entry.feerate_satvb(), txid});
                 resolved_fees += entry.fee;
                 ++resolved;
             } else {
@@ -346,8 +362,8 @@ class Mempool {
         uint32_t total_bytes = 0;
         auto* utxo = m_utxo.load();
 
-        for (const auto& [feerate, txid] : m_feerate_index) {
-            (void)feerate;
+        for (const auto& fk : m_feerate_index) {
+            const uint256& txid = fk.txid;
             auto pit = m_pool.find(txid);
             if (pit == m_pool.end()) continue;
             const auto& entry = pit->second;
@@ -388,7 +404,7 @@ class Mempool {
     std::map<std::pair<uint256, uint32_t>, uint256>    m_spent_outputs;
     // Step 2: feerate-sorted index. greater<double> means begin() =
     // highest feerate, so iteration is best-first.
-    std::multimap<double, uint256, std::greater<double>> m_feerate_index;
+    std::set<FeeKey>                                   m_feerate_index;
     size_t                                             m_total_bytes{0};
     size_t                                             m_max_bytes;
     time_t                                             m_expiry_sec;
@@ -415,13 +431,7 @@ class Mempool {
 
         // Drop from feerate index (only present if fee was known).
         if (it->second.fee_known) {
-            auto frng = m_feerate_index.equal_range(it->second.feerate_satvb());
-            for (auto rit = frng.first; rit != frng.second; ++rit) {
-                if (rit->second == txid) {
-                    m_feerate_index.erase(rit);
-                    break;
-                }
-            }
+            m_feerate_index.erase(FeeKey{it->second.feerate_satvb(), txid});
         }
 
         // Drop from spent-outputs index.

test/test_dash_mempool.cpp

@@ -25,7 +25,9 @@
 #include <core/uint256.hpp>
 #include <core/coin/utxo_view_cache.hpp>
 
+#include <algorithm>
 #include <cstdint>
+#include <vector>
 
 using dash::coin::Mempool;
 using dash::coin::MutableTransaction;
@@ -254,3 +256,63 @@ TEST(DashMempool, SortedSelectionHighestFeerateFirst)
     EXPECT_EQ(dash_txid(selected[1].tx), dash_txid(tx_lo));
     EXPECT_EQ(total_fees, 11'000u);
 }
+
+// ─── G1 byte-parity: equal-feerate selection is deterministic ────────────────
+//
+// The embedded GBT template builder serializes txs in the order
+// get_sorted_txs_with_fees() returns them. For txs sharing the SAME
+// feerate the old std::multimap<double,uint256> kept them in mempool
+// INSERTION order, so two nodes with the same mempool contents but a
+// different arrival order produced different template bytes — a
+// non-deterministic seam that breaks G1 byte-parity against the
+// p2pool-dash / dashcore oracle. FeeKey now breaks feerate ties by txid
+// ascending (matches dashcore CompareTxMemPoolEntryByAncestorFee's
+// GetHash() tiebreak), so the projection is byte-reproducible.
+//
+// This KAT pins that: identical equal-feerate sets added in OPPOSITE
+// orders must yield the SAME selection, ordered by txid ascending.
+static std::vector<uint256> equal_feerate_selection(bool reverse_insertion)
+{
+    UTXOViewCache utxo(nullptr);
+    // 5 distinct prevouts, identical value ⇒ identical fee & base_size
+    // ⇒ identical feerate for every spend below.
+    constexpr int N = 5;
+    std::vector<MutableTransaction> txs;
+    for (int i = 0; i < N; ++i) {
+        uint256 prev = mint_hash(200 + i);
+        utxo.add_coin(Outpoint(prev, 0), Coin(100'000, {}, 1, false));
+        txs.push_back(make_spend(prev, 0, /*out=*/95'000, /*salt=*/300 + i)); // fee 5000
+    }
+
+    Mempool mp;
+    mp.set_utxo(&utxo);
+    if (reverse_insertion)
+        for (auto it = txs.rbegin(); it != txs.rend(); ++it) EXPECT_TRUE(mp.add_tx(*it));
+    else
+        for (auto& t : txs) EXPECT_TRUE(mp.add_tx(t));
+
+    auto [selected, total_fees] = mp.get_sorted_txs_with_fees(/*max_bytes=*/1u << 20);
+    EXPECT_EQ(total_fees, static_cast<uint64_t>(N) * 5'000u);
+    std::vector<uint256> out;
+    for (auto& s : selected) out.push_back(dash_txid(s.tx));
+    return out;
+}
+
+TEST(DashMempool, EqualFeerateSelectionIsTxidAscendingAndInsertionOrderIndependent)
+{
+    auto forward = equal_feerate_selection(/*reverse_insertion=*/false);
+    auto reverse = equal_feerate_selection(/*reverse_insertion=*/true);
+
+    ASSERT_EQ(forward.size(), 5u);
+    ASSERT_EQ(reverse.size(), 5u);
+
+    // Insertion order must not affect the projected order.
+    EXPECT_EQ(forward, reverse)
+        << "equal-feerate tx order must be independent of mempool arrival order";
+
+    // And that stable order is txid ascending (dashcore GetHash() tiebreak).
+    auto sorted = forward;
+    std::sort(sorted.begin(), sorted.end());
+    EXPECT_EQ(forward, sorted)
+        << "equal-feerate ties must resolve to txid-ascending, oracle-conformant order";
+}