Fix PPLNS: remove desired_weight cap for V36 decayed walks

frstrtr · frstrtr · commit 982aea1ae166 · 2026-03-20T04:04:48.000+04:00
On low-difficulty networks (testnet) where share difficulty exceeds
block difficulty, the PPLNS desired_weight cap (65535 * SPREAD *
block_att) covers only ~2 shares. With V36 exponential decay, the
first share fills most of the cap, causing blocks to pay only the
most recent miner instead of distributing across the full window.

The cap was designed for pre-V36 non-decayed PPLNS to bound total
weight. With exponential decay (half-life = CHAIN_LENGTH/4), old
shares naturally contribute negligibly — the cap is redundant.

Fix: pass unlimited desired_weight for V36 decayed walks in both
generate_share_transaction() and get_expected_payouts(). Pre-V36
paths unchanged. Matches p2pool-merged-v36 commit 4b738ba8.

Also adds test_decay_pplns (5 tests) verifying C++ decay computation
matches Python p2pool exactly, and GENTX-MISMATCH diagnostic dump.
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -87,7 +87,7 @@ jobs:
                     test_header_chain test_mempool test_template_builder \
                     test_doge_chain test_compact_blocks \
                     test_multiaddress_pplns test_pplns_stress \
-                    test_hash_link \
+                    test_hash_link test_decay_pplns \
                     test_phase0_live test_phase1_live test_phase2_live \
                     test_phase3_live test_phase4_embedded test_phase4_live \
             -j$(nproc)
diff --git a/src/impl/ltc/share_check.hpp b/src/impl/ltc/share_check.hpp
@@ -768,7 +768,7 @@ inline std::vector<unsigned char> get_share_script(const auto* obj)
 // Reference: frstrtr/p2pool-merged-v36  p2pool/data.py  generate_transaction()
 // ============================================================================
 template <typename ShareT, typename TrackerT>
-uint256 generate_share_transaction(const ShareT& share, TrackerT& tracker)
+uint256 generate_share_transaction(const ShareT& share, TrackerT& tracker, bool dump_diag = false)
 {
     constexpr int64_t ver = ShareT::version;
     const uint64_t subsidy = share.m_subsidy;
@@ -795,8 +795,13 @@ uint256 generate_share_transaction(const ShareT& share, TrackerT& tracker)
                           * PoolConfig::SPREAD * 65535;
 
         // V36: use exponential depth-decay (matching Python's get_decayed_cumulative_weights)
+        // Remove desired_weight cap — exponential decay naturally limits old shares'
+        // contribution. The cap is harmful on low-difficulty networks (testnet) where
+        // block_att < share_att, truncating the PPLNS window to ~2 shares.
         if constexpr (ver >= 36) {
-            auto result = tracker.get_v36_decayed_cumulative_weights(prev_hash, chain_len, max_weight);
+            uint288 unlimited_weight;
+            unlimited_weight.SetHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+            auto result = tracker.get_v36_decayed_cumulative_weights(prev_hash, chain_len, unlimited_weight);
             weights = std::move(result.weights);
             total_weight = result.total_weight;
             total_donation_weight = result.total_donation_weight;
@@ -1156,7 +1161,53 @@ uint256 generate_share_transaction(const ShareT& share, TrackerT& tracker)
     // --- 5. Compute txid (double-SHA256 of non-witness serialization) ---
     auto tx_span = std::span<const unsigned char>(
         reinterpret_cast<const unsigned char*>(tx.data()), tx.size());
-    return Hash(tx_span);
+    auto txid = Hash(tx_span);
+
+    if (dump_diag)
+    {
+        const char* HX = "0123456789abcdef";
+        auto to_hex = [&](const unsigned char* p, size_t len) {
+            std::string h; h.reserve(len * 2);
+            for (size_t i = 0; i < len; ++i) { h += HX[p[i] >> 4]; h += HX[p[i] & 0xf]; }
+            return h;
+        };
+
+        auto* cp = reinterpret_cast<const unsigned char*>(tx.data());
+        LOG_WARNING << "[GENTX-DIAG] coinbase_len=" << tx.size() << " txid=" << txid.GetHex();
+        LOG_WARNING << "[GENTX-DIAG] coinbase_hex=" << to_hex(cp, tx.size());
+        LOG_WARNING << "[GENTX-DIAG] pplns_outputs=" << payout_outputs.size()
+                    << " donation_amount=" << donation_amount
+                    << " n_outs=" << n_outs
+                    << " has_segwit=" << has_segwit;
+        LOG_WARNING << "[GENTX-DIAG] total_weight=" << total_weight.GetHex()
+                    << " total_don_weight=" << total_donation_weight.GetHex();
+        for (size_t i = 0; i < payout_outputs.size(); ++i) {
+            auto& [s, a] = payout_outputs[i];
+            LOG_WARNING << "[GENTX-DIAG]  payout[" << i << "] amount=" << a
+                        << " script=" << to_hex(s.data(), s.size());
+        }
+        // First 5 shares in walk
+        if (!share.m_prev_hash.IsNull() && tracker.chain.contains(share.m_prev_hash)) {
+            auto cl = std::min(tracker.chain.get_height(share.m_prev_hash),
+                               static_cast<int32_t>(PoolConfig::real_chain_length()));
+            auto wv = tracker.chain.get_chain(share.m_prev_hash, std::min(cl, int32_t(5)));
+            int si = 0;
+            for (auto& [h, d] : wv) {
+                d.share.invoke([&](auto* obj) {
+                    auto att = chain::target_to_average_attempts(chain::bits_to_target(obj->m_bits));
+                    auto sc = get_share_script(obj);
+                    LOG_WARNING << "[GENTX-DIAG]  walk[" << si << "] hash=" << h.ToString().substr(0,16)
+                                << " bits=0x" << std::hex << obj->m_bits << std::dec
+                                << " att=" << att.GetHex()
+                                << " don=" << obj->m_donation
+                                << " script=" << to_hex(sc.data(), sc.size());
+                });
+                ++si;
+            }
+        }
+    }
+
+    return txid;
 }
 
 // ============================================================================
@@ -1361,14 +1412,22 @@ bool share_check(const ShareT& share,
                         << " prev=" << share.m_prev_hash.ToString().substr(0,16);
             LOG_WARNING << "  expected_gentx=" << expected_gentx.ToString().substr(0,32)
                         << " actual_gentx=" << gentx_hash.ToString().substr(0,32);
-            
+
             auto chain_len = std::min(
                 tracker.chain.get_height(share.m_prev_hash),
                 static_cast<int32_t>(PoolConfig::real_chain_length()));
             LOG_WARNING << "  PPLNS chain_len=" << chain_len
                         << " prev_height=" << tracker.chain.get_height(share.m_prev_hash)
                         << " real_chain_length=" << PoolConfig::real_chain_length();
 
+            // --- Detailed diagnostics: re-run with full dump ---
+            static int s_diag_count = 0;
+            if (s_diag_count++ < 2)
+            {
+                LOG_WARNING << "[GENTX-DIAG] Re-running generate_share_transaction with full dump:";
+                generate_share_transaction(share, tracker, true);
+            }
+
             throw std::invalid_argument("GenerateShareTransaction mismatch — coinbase does not match PPLNS payouts");
         }
     }
diff --git a/src/impl/ltc/share_tracker.hpp b/src/impl/ltc/share_tracker.hpp
@@ -867,11 +867,11 @@ class ShareTracker
     {
         auto chain_len = std::min(chain.get_height(best_share_hash),
                                   static_cast<int32_t>(PoolConfig::real_chain_length()));
-        auto max_weight = chain::target_to_average_attempts(block_target)
-                          * PoolConfig::SPREAD * 65535;
-
-        // V36: use exponential depth-decay (matching Python's get_decayed_cumulative_weights)
-        auto [weights, total_weight, donation_weight] = get_v36_decayed_cumulative_weights(best_share_hash, chain_len, max_weight);
+        // V36: remove desired_weight cap — exponential decay handles windowing.
+        // See generate_share_transaction() for detailed rationale.
+        uint288 unlimited_weight;
+        unlimited_weight.SetHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+        auto [weights, total_weight, donation_weight] = get_v36_decayed_cumulative_weights(best_share_hash, chain_len, unlimited_weight);
 
         std::map<std::vector<unsigned char>, double> result;
         uint64_t sum = 0;
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
@@ -217,4 +217,13 @@ if (BUILD_TESTING AND GTest_FOUND)
         ${Boost_LIBRARIES}
     )
     gtest_add_tests(test_hash_link "" AUTO)
+
+    add_executable(test_decay_pplns test_decay_pplns.cpp)
+    target_link_libraries(test_decay_pplns PRIVATE
+        GTest::gtest_main GTest::gtest
+        core ltc
+        nlohmann_json::nlohmann_json
+        ${Boost_LIBRARIES}
+    )
+    gtest_add_tests(test_decay_pplns "" AUTO)
 endif()
diff --git a/test/test_decay_pplns.cpp b/test/test_decay_pplns.cpp
@@ -0,0 +1,246 @@
+#include <gtest/gtest.h>
+#include <core/uint256.hpp>
+#include <cstdint>
+#include <map>
+#include <string>
+#include <vector>
+
+// Replicate the decay PPLNS computation from share_tracker.hpp
+// to verify it matches Python exactly.
+
+struct DecayResult {
+    std::map<std::string, uint288> weights;
+    uint288 total_weight;
+    uint288 total_donation_weight;
+};
+
+struct ShareData {
+    uint64_t att;
+    uint32_t donation;
+    std::string address;
+};
+
+DecayResult compute_decayed_weights(
+    const std::vector<ShareData>& shares,
+    int32_t max_shares,
+    const uint288& desired_weight,
+    uint32_t chain_length)
+{
+    static constexpr uint64_t DECAY_PRECISION = 40;
+    static constexpr uint64_t DECAY_SCALE = uint64_t(1) << DECAY_PRECISION;
+    static constexpr uint64_t LN2_MICRO = 693147;
+
+    uint32_t half_life = std::max(chain_length / 4, uint32_t(1));
+    uint64_t decay_per = DECAY_SCALE - (DECAY_SCALE * LN2_MICRO) / (uint64_t(1000000) * half_life);
+
+    DecayResult result;
+    int32_t share_count = 0;
+    uint64_t decay_fp = DECAY_SCALE;
+
+    for (const auto& share : shares)
+    {
+        if (share_count >= max_shares)
+            break;
+
+        uint288 att(share.att);
+        uint32_t don = share.donation;
+
+        uint288 decayed_att = (att * uint288(decay_fp)) >> DECAY_PRECISION;
+
+        auto addr_w = decayed_att * static_cast<uint32_t>(65535 - don);
+        auto don_w = decayed_att * don;
+        auto this_total = addr_w + don_w;
+
+        if (result.total_weight + this_total > desired_weight) {
+            auto remaining = desired_weight - result.total_weight;
+            if (!this_total.IsNull()) {
+                addr_w = addr_w * remaining / this_total;
+                don_w = don_w * remaining / this_total;
+            }
+            this_total = remaining;
+        }
+
+        result.weights[share.address] += addr_w;
+        result.total_weight += this_total;
+        result.total_donation_weight += don_w;
+
+        ++share_count;
+        if (result.total_weight >= desired_weight)
+            break;
+
+        decay_fp = static_cast<uint64_t>(
+            (static_cast<__uint128_t>(decay_fp) * decay_per) >> DECAY_PRECISION);
+    }
+
+    return result;
+}
+
+TEST(DecayPPLNS, MatchesPythonExactValues)
+{
+    // Same 10-share test case as Python test_output_for_cpp_comparison
+    std::vector<ShareData> shares = {
+        {1000000, 50, "addr_A"},
+        {2000000, 50, "addr_B"},
+        {1500000, 50, "addr_A"},
+        {1000000, 50, "addr_B"},
+        {3000000, 50, "addr_A"},
+        {1000000, 50, "addr_B"},
+        {1000000, 50, "addr_A"},
+        {2000000, 50, "addr_B"},
+        {1000000, 50, "addr_A"},
+        {1500000, 50, "addr_B"},
+    };
+
+    uint288 unlimited;
+    unlimited.SetHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+
+    auto result = compute_decayed_weights(shares, 10, unlimited, 400);
+
+    // Expected values from Python:
+    // total_weight=953350555395
+    // total_donation_weight=727359850
+    // weight[addr_A]=478168850600
+    // weight[addr_B]=474454344945
+    EXPECT_EQ(result.total_weight.GetLow64(), uint64_t(953350555395));
+    EXPECT_EQ(result.total_donation_weight.GetLow64(), uint64_t(727359850));
+    EXPECT_EQ(result.weights["addr_A"].GetLow64(), uint64_t(478168850600));
+    EXPECT_EQ(result.weights["addr_B"].GetLow64(), uint64_t(474454344945));
+
+    // Verify: weights + donation = total
+    uint288 sum_weights = result.weights["addr_A"] + result.weights["addr_B"];
+    EXPECT_EQ(sum_weights + result.total_donation_weight, result.total_weight);
+}
+
+TEST(DecayPPLNS, TwoMinersAlternating400Shares)
+{
+    // 400 shares, miners alternate, unlimited weight
+    std::vector<ShareData> shares;
+    for (int i = 0; i < 400; ++i)
+        shares.push_back({1541819, 0, (i % 2 == 0) ? "A" : "B"});
+
+    uint288 unlimited;
+    unlimited.SetHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+
+    auto result = compute_decayed_weights(shares, 400, unlimited, 400);
+
+    // Python: A=6861325693665, B=6813766223280, total=13675091916945
+    EXPECT_EQ(result.weights["A"].GetLow64(), uint64_t(6861325693665));
+    EXPECT_EQ(result.weights["B"].GetLow64(), uint64_t(6813766223280));
+    EXPECT_EQ(result.total_weight.GetLow64(), uint64_t(13675091916945));
+
+    // Check payout amounts
+    uint64_t subsidy = 156250000;
+    uint64_t amt_A = (uint288(subsidy) * result.weights["A"] / result.total_weight).GetLow64();
+    uint64_t amt_B = (uint288(subsidy) * result.weights["B"] / result.total_weight).GetLow64();
+
+    // Python: A=78396704, B=77853295
+    EXPECT_EQ(amt_A, uint64_t(78396704));
+    EXPECT_EQ(amt_B, uint64_t(77853295));
+}
+
+TEST(DecayPPLNS, CappedVsUnlimited)
+{
+    // Verify that capped desired_weight truncates to ~2 shares
+    std::vector<ShareData> shares;
+    for (int i = 0; i < 400; ++i)
+        shares.push_back({1541819, 0, (i % 2 == 0) ? "A" : "B"});
+
+    // Capped: block_att * SPREAD * 65535
+    uint64_t block_att = 1048577;
+    uint288 capped_desired = uint288(65535) * uint288(3) * uint288(block_att);
+
+    auto result_cap = compute_decayed_weights(shares, 400, capped_desired, 400);
+
+    // Capped total should equal desired_weight exactly (cap was hit)
+    EXPECT_EQ(result_cap.total_weight, capped_desired);
+
+    // With unlimited
+    uint288 unlimited;
+    unlimited.SetHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+    auto result_ulim = compute_decayed_weights(shares, 400, unlimited, 400);
+
+    // Unlimited total should be much larger
+    EXPECT_TRUE(result_ulim.total_weight > capped_desired);
+
+    // Both should have 2 addresses
+    EXPECT_EQ(result_cap.weights.size(), 2u);
+    EXPECT_EQ(result_ulim.weights.size(), 2u);
+
+    // Unlimited should give more equal distribution
+    uint64_t subsidy = 156250000;
+    uint64_t cap_A = (uint288(subsidy) * result_cap.weights["A"] / result_cap.total_weight).GetLow64();
+    uint64_t cap_B = (uint288(subsidy) * result_cap.weights["B"] / result_cap.total_weight).GetLow64();
+    uint64_t ulim_A = (uint288(subsidy) * result_ulim.weights["A"] / result_ulim.total_weight).GetLow64();
+    uint64_t ulim_B = (uint288(subsidy) * result_ulim.weights["B"] / result_ulim.total_weight).GetLow64();
+
+    // Unlimited should be closer to 50/50
+    int64_t cap_diff = std::abs(int64_t(cap_A) - int64_t(cap_B));
+    int64_t ulim_diff = std::abs(int64_t(ulim_A) - int64_t(ulim_B));
+    EXPECT_LT(ulim_diff, cap_diff);
+
+    std::cout << "Capped:    A=" << cap_A << " B=" << cap_B << " diff=" << cap_diff << std::endl;
+    std::cout << "Unlimited: A=" << ulim_A << " B=" << ulim_B << " diff=" << ulim_diff << std::endl;
+}
+
+TEST(DecayPPLNS, DecayConverges)
+{
+    // Total weight should converge as we add more shares
+    // (decay makes old shares negligible)
+    std::vector<ShareData> shares;
+    for (int i = 0; i < 4000; ++i)
+        shares.push_back({1541819, 50, "miner"});
+
+    uint288 unlimited;
+    unlimited.SetHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+
+    auto r400 = compute_decayed_weights(shares, 400, unlimited, 400);
+    auto r4000 = compute_decayed_weights(shares, 4000, unlimited, 400);
+
+    // Ratio should be close to 1.0 (within 10%)
+    // Python: ratio = 1.065979
+    double ratio = static_cast<double>(r4000.total_weight.GetLow64()) /
+                   static_cast<double>(r400.total_weight.GetLow64());
+    EXPECT_GT(ratio, 1.0);
+    EXPECT_LT(ratio, 1.1);
+
+    std::cout << "400 shares:  total_weight=" << r400.total_weight.GetLow64() << std::endl;
+    std::cout << "4000 shares: total_weight=" << r4000.total_weight.GetLow64() << std::endl;
+    std::cout << "Ratio: " << ratio << std::endl;
+}
+
+TEST(DecayPPLNS, PerShareDecayFactors)
+{
+    // Verify individual decay_fp values match Python
+    static constexpr uint64_t DECAY_PRECISION = 40;
+    static constexpr uint64_t DECAY_SCALE = uint64_t(1) << DECAY_PRECISION;
+    static constexpr uint64_t LN2_MICRO = 693147;
+
+    uint32_t chain_length = 400;
+    uint32_t half_life = chain_length / 4; // = 100
+    uint64_t decay_per = DECAY_SCALE - (DECAY_SCALE * LN2_MICRO) / (uint64_t(1000000) * half_life);
+
+    // Python: decay_per=1091890395914 (hex: fe39bd3b0a)
+    EXPECT_EQ(decay_per, uint64_t(1091890395914));
+
+    // Verify first few decay_fp values
+    uint64_t decay_fp = DECAY_SCALE;
+    uint64_t expected_fps[] = {
+        1099511627776,  // share[0]
+        1091890395914,  // share[1]
+        1084321990392,  // share[2]
+        1076806045045,  // share[3]
+        1069342196248,  // share[4]
+    };
+
+    for (int i = 0; i < 5; ++i) {
+        EXPECT_EQ(decay_fp, expected_fps[i]) << "Mismatch at share " << i;
+        decay_fp = static_cast<uint64_t>(
+            (static_cast<__uint128_t>(decay_fp) * decay_per) >> DECAY_PRECISION);
+    }
+}
+
+int main(int argc, char** argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
