Dash Phase C-PAY: account for DIP-0027 platform reward in MN payment

Live-discovered 2026-05-14 on .41 PAY soak: [MN-PAY] MISMATCH at every
post-MN_RR block with constant diff=-49,787,579 sat. Tracked to block
2,470,904 having three coinbase outputs: 49,787,579 OP_RETURN (platform
credit pool burn) + 83,056,309 MN payee + 44,281,297 miner. Total =
177,125,185 = subsidy(177,022,505) + fees(102,680).

c2pool was using the pre-DIP-0027 formula `expected = block_value × 3/4`
which assumes the MN gets 75% of (subsidy + fees). Real chain (post both
V20 h=1,987,776 AND MN_RR h=2,128,896) burns 9/32 of subsidy at L1 to
mint Platform credit at L2, with the burn coming entirely from the MN's
portion — miner share unchanged.

Mirror dashcore PlatformShare() at masternode/payments.cpp:28-58:
  mn_subsidy_share = subsidy × 3/4
  platform_reward  = mn_subsidy_share × 375/1000 (= 9/32 of subsidy)
  mn_payment      -= platform_reward
The integer-truncation order matters; 9/32 alone isn't bit-exact.

Three sites updated:
  - subsidy.hpp: add DASH_MN_RR_HEIGHT_MAINNET + helper, dashcore order
  - main_dash.cpp [MN-PAY] check: subtract platform from expected
  - embedded_gbt.hpp: subtract from MN payment + emit OP_RETURN entry
    FIRST in m_packed_payments (matches dashcore vout ordering)

The third site is consensus-critical for the future embedded-as-primary
cutover; without it every template c2pool builds would be rejected by
mainnet. Currently [GBT-XCHECK] would mismatch on every post-MN_RR block;
this commit also fixes that.

3 new tests pin the formula bit-exact against block 2,470,904.

Author: frstrtr

src/impl/dash/coin/embedded_gbt.hpp

@@ -76,8 +76,9 @@ inline DashWorkData build_embedded_workdata(
     constexpr uint32_t MAX_BLOCK_BYTES = 1'990'000;  // leave headroom for cb
     auto [selected, total_fees] =
         mempool.get_sorted_txs_with_fees(MAX_BLOCK_BYTES);
-    int64_t block_value = reward + total_fees;
-    int64_t mn_payment  = compute_dash_mn_payment_post_v20(block_value);
+    int64_t block_value      = reward + total_fees;
+    int64_t platform_reward  = compute_dash_platform_reward_post_v20_mn_rr(w.m_height);
+    int64_t mn_payment       = compute_dash_mn_payment_post_v20(block_value) - platform_reward;
 
     w.m_coinbase_value  = static_cast<uint64_t>(block_value);
     w.m_payment_amount  = static_cast<uint64_t>(mn_payment);
@@ -93,6 +94,16 @@ inline DashWorkData build_embedded_workdata(
         w.m_tx_fees.push_back(s.fee);
     }
 
+    // Platform Credit Pool burn (DIP-0027): emit OP_RETURN payment
+    // FIRST (matches dashcore GetBlockTxOuts ordering at payments.cpp:55).
+    // Payee uses the "!hex" raw-script convention; OP_RETURN single byte = 0x6a.
+    if (platform_reward > 0) {
+        PackedPayment burn;
+        burn.payee  = "!6a";
+        burn.amount = static_cast<uint64_t>(platform_reward);
+        w.m_packed_payments.push_back(std::move(burn));
+    }
+
     // MN payee → packed_payment. dashcore GBT returns "payee" as a
     // base58 address. We use script_to_address() to produce the same
     // wire form for standard P2PKH/P2SH scripts. Unrecognized script

src/impl/dash/coin/subsidy.hpp

@@ -43,6 +43,7 @@ inline constexpr int64_t COIN_SAT = 100'000'000LL;
 inline constexpr int DASH_SUBSIDY_HALVING_INTERVAL = 210240;
 inline constexpr int DASH_V20_HEIGHT_MAINNET       = 1'987'776;
 inline constexpr int DASH_BRR_HEIGHT_MAINNET       = 1'374'912;
+inline constexpr int DASH_MN_RR_HEIGHT_MAINNET     = 2'128'896;
 inline constexpr int DASH_SUPERBLOCK_CYCLE_MAINNET = 16616;
 
 /// Returns the BLOCK reward (excluding tx fees) for a block at height
@@ -74,6 +75,21 @@ inline int64_t compute_dash_mn_payment_post_v20(int64_t block_value)
     return block_value * 3 / 4;
 }
 
+/// Platform Credit Pool burn (DIP-0027 / Asset Lock) per-block share.
+/// Activates when both V20 AND MN_RR are deployed (mainnet h>=MN_RR=2,128,896,
+/// our checkpoint h=2.4M is always past). Mirror of dashcore PlatformShare()
+/// at masternode/payments.cpp: PlatformShare(GetMasternodePayment(h, subsidy, true))
+/// = (subsidy * 3/4) * 375/1000. Integer-arithmetic order matters: dashcore
+/// truncates between the two divisions, so we replicate that order exactly.
+/// The result is added as an OP_RETURN coinbase output and DEDUCTED from the
+/// MN's portion (miner share is unaffected).
+inline int64_t compute_dash_platform_reward_post_v20_mn_rr(uint32_t height)
+{
+    if (static_cast<int>(height) < DASH_MN_RR_HEIGHT_MAINNET) return 0;
+    int64_t mn_subsidy_share = compute_dash_block_reward_post_v20(height) * 3 / 4;
+    return mn_subsidy_share * 375 / 1000;
+}
+
 /// True if `height` is a superblock height (treasury budget payout).
 inline bool is_superblock_height(uint32_t height,
                                  int cycle = DASH_SUPERBLOCK_CYCLE_MAINNET)

src/impl/dash/main_dash.cpp

@@ -2779,22 +2779,25 @@ int main(int argc, char* argv[])
                                     auto fees_opt = dash::coin::computed_block_fees(
                                         block, utxo);
                                     if (fees_opt.has_value()) {
+                                        int64_t platform =
+                                            dash::coin::compute_dash_platform_reward_post_v20_mn_rr(
+                                                height);
                                         int64_t expected_mn =
                                             dash::coin::compute_dash_mn_payment_post_v20(
-                                                reward + *fees_opt);
+                                                reward + *fees_opt) - platform;
                                         if (observed_mn_amount == expected_mn) {
                                             LOG_INFO << "[MN-PAY] match h=" << height
                                                      << " mn_payment=" << observed_mn_amount
                                                      << " (reward=" << reward
                                                      << " + fees=" << *fees_opt
-                                                     << " ×3/4)";
+                                                     << " ×3/4 - platform=" << platform << ")";
                                         } else {
                                             LOG_WARNING << "[MN-PAY] MISMATCH h=" << height
                                                         << " observed=" << observed_mn_amount
                                                         << " expected=" << expected_mn
                                                         << " (reward=" << reward
                                                         << " + fees=" << *fees_opt
-                                                        << " ×3/4)"
+                                                        << " ×3/4 - platform=" << platform << ")"
                                                         << " diff=" << (observed_mn_amount - expected_mn)
                                                         << " — log-only at MVP";
                                         }

test/test_dash_subsidy.cpp

@@ -33,6 +33,7 @@
 
 using dash::coin::compute_dash_block_reward_post_v20;
 using dash::coin::compute_dash_mn_payment_post_v20;
+using dash::coin::compute_dash_platform_reward_post_v20_mn_rr;
 
 // ─── Tests ──────────────────────────────────────────────────────────────────
 
@@ -84,3 +85,51 @@ TEST(DashSubsidy, SuperblockHeightDetectionMainnet)
     EXPECT_FALSE(dash::coin::is_superblock_height(16615, 16616));
     EXPECT_FALSE(dash::coin::is_superblock_height(16617, 16616));
 }
+
+TEST(DashSubsidy, PlatformRewardZeroBeforeMN_RR)
+{
+    // MN_RR mainnet activation = h=2,128,896. Before that, platform_reward
+    // must be zero (pre-DIP-0027 split with no asset-lock burn output).
+    EXPECT_EQ(compute_dash_platform_reward_post_v20_mn_rr(2'128'895), 0);
+    EXPECT_EQ(compute_dash_platform_reward_post_v20_mn_rr(1'987'776), 0);
+    EXPECT_EQ(compute_dash_platform_reward_post_v20_mn_rr(0), 0);
+}
+
+TEST(DashSubsidy, PlatformRewardMatchesMainnetH2470904)
+{
+    // Live-validated against Dash mainnet block 2470904 (2026-05-13):
+    //   coinbase vout[0] value=0.49787579 DASH = 49,787,579 sat (OP_RETURN burn)
+    //   coinbase vout[1] value=0.83056309 DASH = 83,056,309 sat (MN payee)
+    //   coinbase vout[2] value=0.44281297 DASH = 44,281,297 sat (miner)
+    //   block reward = 177,022,505 sat (this height has 11 halvings applied)
+    //   fees         = 102,680 sat (computed from in-block tx fees)
+    //
+    // Formula (dashcore masternode/payments.cpp:28-58):
+    //   mn_subsidy_share = block_reward × 3/4 = 132,766,878 (floored)
+    //   platform_reward  = mn_subsidy_share × 375/1000 = 49,787,579 (floored)
+    constexpr uint32_t H = 2'470'904;
+    EXPECT_EQ(compute_dash_block_reward_post_v20(H), 177'022'505LL);
+    EXPECT_EQ(compute_dash_platform_reward_post_v20_mn_rr(H), 49'787'579LL);
+
+    // expected_mn (for [MN-PAY] shadow check) = (subsidy+fees) × 3/4 - platform
+    int64_t reward       = compute_dash_block_reward_post_v20(H);
+    int64_t fees         = 102'680LL;
+    int64_t platform     = compute_dash_platform_reward_post_v20_mn_rr(H);
+    int64_t expected_mn  = compute_dash_mn_payment_post_v20(reward + fees) - platform;
+    EXPECT_EQ(expected_mn, 83'056'309LL)
+        << "must match observed MN coinbase output at h=2,470,904";
+}
+
+TEST(DashSubsidy, PlatformReward28125PercentOfBlockReward)
+{
+    // Per dashcore: platform = (block_reward × 3/4) × 375/1000.
+    // For any block_reward where the math is exact (no truncation),
+    // platform = block_reward × 9/32 = 28.125%. At h=2,400,000 (post-MN_RR)
+    // the live values produce small truncation noise but the proportion
+    // should hold within 1 sat.
+    int64_t r = compute_dash_block_reward_post_v20(2'400'000);
+    int64_t p = compute_dash_platform_reward_post_v20_mn_rr(2'400'000);
+    int64_t expected_exact = (r * 9) / 32;
+    EXPECT_LE(std::abs(p - expected_exact), 1LL)
+        << "platform should match 9/32 of block_reward within int-truncation";
+}