Fix V36 GENTX mismatch: off-by-one in HeadPPLNS ring buffer extension

The extend_backward slide in think() Phase 2 took deep_hash.tail
(depth 400) instead of deep_hash itself (depth 399) when adding the
new tail entry to the ring buffer. Each extension shifted the last
entry one share too deep, accumulating PPLNS weight errors of 300-700
satoshi per address — enough to fail every V36 GENTX verification.

Fix: pass deep_hash directly to extend_backward instead of deeper.
Testnet: verified gap 391 → 0. Mainnet: 86 V36 failures now resolved.

Also adds GENTX mismatch diagnostics (PPLNS walk dump, hash_link
comparison, PPLNS-empty trace) and fixes current_payouts zero-address
display during bootstrap.

Author: frstrtr

.gitignore

@@ -151,5 +151,13 @@ test/test_*_include.cmake
 !test/test_*.cpp
 !test/test_*.hpp
 !test/test_*.h
-CLAUDE.md
+
+# Release artifacts
+*.tar.gz
+*.tar.bz2
+*.dmg
+*.msi
+*.deb
+SHA256SUMS
+
 CLAUDE.md

src/core/web_server.cpp

@@ -2129,8 +2129,24 @@ void MiningInterface::refresh_work()
             }
 
             // Fallback: single output to zero-key (burn) so coinbase is always valid
-            if (pplns_outputs.empty())
+            if (pplns_outputs.empty()) {
                 pplns_outputs.push_back({"0000000000000000000000000000000000000000", coinbase_value});
+                // Diagnostic: trace WHY PPLNS is empty — this causes invalid coinbase
+                static int zero_warn = 0;
+                if (zero_warn++ < 10 || zero_warn % 100 == 0) {
+                    bool has_pplns = static_cast<bool>(m_pplns_fn);
+                    bool has_best = static_cast<bool>(m_best_share_hash_fn);
+                    uint256 best_hash;
+                    if (has_best) best_hash = m_best_share_hash_fn();
+                    LOG_WARNING << "[PPLNS-EMPTY] Falling back to zero-address burn!"
+                                << " has_pplns_fn=" << has_pplns
+                                << " has_best_fn=" << has_best
+                                << " best_hash=" << (best_hash.IsNull() ? "null" : best_hash.GetHex().substr(0, 16))
+                                << " subsidy=" << coinbase_value
+                                << " donation_script_len=" << m_donation_script.size()
+                                << " (#" << zero_warn << ")";
+                }
+            }
 
             // Get merged mining commitment if an MM manager is wired.
             // Only rebuild when PPLNS weights changed (new best_share).
@@ -2909,7 +2925,14 @@ nlohmann::json MiningInterface::rest_current_payouts()
     // These are always up-to-date with the latest share template and subsidy.
     auto cached = get_cached_pplns_outputs();
     if (!cached.empty()) {
+        // Skip zero-address burn entries (20-byte zero hash from PPLNS-empty fallback).
+        // These are not real payouts — they indicate PPLNS is not yet computed.
+        static const std::string zero_burn = "0000000000000000000000000000000000000000";
+
         for (const auto& [script_hex, amount] : cached) {
+            if (script_hex == zero_burn)
+                continue;  // Don't expose the burn placeholder to the API
+
             // script_hex is a hex-encoded scriptPubKey — decode to bytes, then to address
             auto script_bytes = ParseHex(script_hex);
             std::string addr = core::script_to_address(script_bytes, is_ltc, m_testnet);

src/impl/ltc/share_check.hpp

@@ -1374,6 +1374,53 @@ uint256 generate_share_transaction(const ShareT& share, TrackerT& tracker, bool
         reinterpret_cast<const unsigned char*>(tx.data()), tx.size());
     auto txid = Hash(tx_span);
 
+    // V36 hash_link cross-check: compute prefix hash_link from our coinbase
+    // and compare with the share's stored hash_link. If states differ,
+    // the prefix (outputs/amounts) differs from what p2pool built.
+    if (dump_diag && use_v36_pplns)
+    {
+        if constexpr (requires { share.m_hash_link.m_extra_data; })
+        {
+            auto gbr = compute_gentx_before_refhash(ver);
+            // prefix = full coinbase minus last 44 bytes (ref_hash 32 + nonce 8 + locktime 4)
+            size_t prefix_len = tx.size() - 44;
+            std::vector<unsigned char> prefix(
+                reinterpret_cast<const unsigned char*>(tx.data()),
+                reinterpret_cast<const unsigned char*>(tx.data()) + prefix_len);
+            auto computed_hl = prefix_to_hash_link(prefix, gbr);
+
+            bool state_match = (computed_hl.m_state.m_data == share.m_hash_link.m_state.m_data);
+            bool extra_match = (computed_hl.m_extra_data.m_data == share.m_hash_link.m_extra_data.m_data);
+            bool len_match = (computed_hl.m_length == share.m_hash_link.m_length);
+
+            static const char* HXD = "0123456789abcdef";
+            auto hex_fn = [&](const auto& v) {
+                std::string h; for (auto b : v) { h += HXD[(uint8_t)b >> 4]; h += HXD[(uint8_t)b & 0xf]; } return h;
+            };
+
+            LOG_WARNING << "[HASHLINK-CMP] state_match=" << (state_match ? "YES" : "NO")
+                        << " extra_match=" << (extra_match ? "YES" : "NO")
+                        << " len_match=" << (len_match ? "YES" : "NO")
+                        << " c2pool_len=" << computed_hl.m_length
+                        << " share_len=" << share.m_hash_link.m_length;
+            if (!state_match) {
+                LOG_WARNING << "[HASHLINK-CMP] c2pool_state=" << hex_fn(computed_hl.m_state.m_data);
+                LOG_WARNING << "[HASHLINK-CMP] share_state =" << hex_fn(share.m_hash_link.m_state.m_data);
+            }
+            if (!extra_match) {
+                LOG_WARNING << "[HASHLINK-CMP] c2pool_extra=" << hex_fn(computed_hl.m_extra_data.m_data)
+                            << " (" << computed_hl.m_extra_data.m_data.size() << " bytes)";
+                LOG_WARNING << "[HASHLINK-CMP] share_extra =" << hex_fn(share.m_hash_link.m_extra_data.m_data)
+                            << " (" << share.m_hash_link.m_extra_data.m_data.size() << " bytes)";
+            }
+            // Also dump prefix length and the last 60 bytes for comparison
+            LOG_WARNING << "[HASHLINK-CMP] prefix_len=" << prefix_len
+                        << " gbr_len=" << gbr.size()
+                        << " prefix_tail=" << hex_fn(std::vector<unsigned char>(
+                            prefix.end() - std::min(prefix.size(), size_t(60)), prefix.end()));
+        }
+    }
+
     // One-time full coinbase hex dump for cross-implementation debugging
     {
         static int coinbase_dump_count = 0;
@@ -1798,6 +1845,15 @@ bool share_check(const ShareT& share,
             {
                 LOG_WARNING << "[GENTX-DIAG] Re-running generate_share_transaction with full dump (v36_active=" << v36_active << "):";
                 generate_share_transaction(share, tracker, true, v36_active);
+
+                // Per-share PPLNS walk dump — compare with p2pool's [PARENT-PPLNS] output.
+                // Uses same parameters as generate_share_transaction's V36 path.
+                if (v36_active && !share.m_prev_hash.IsNull()) {
+                    auto diag_chain_len = static_cast<int32_t>(PoolConfig::real_chain_length());
+                    LOG_WARNING << "[GENTX-DIAG] Per-share V36 PPLNS walk from prev="
+                                << share.m_prev_hash.GetHex().substr(0, 16) << ":";
+                    tracker.dump_v36_pplns_walk(share.m_prev_hash, diag_chain_len);
+                }
             }
 
             throw std::invalid_argument("GenerateShareTransaction mismatch — coinbase does not match PPLNS payouts");

src/impl/ltc/share_tracker.hpp

@@ -34,6 +34,7 @@ inline uint64_t mul128_shift(uint64_t a, uint64_t b, unsigned shift) {
 #include <chrono>
 #include <deque>
 #include <functional>
+#include <iomanip>
 #include <map>
 #include <optional>
 #include <set>
@@ -960,23 +961,24 @@ class ShareTracker
                                 LOG_INFO << "[PPLNS-RING] built: window=" << head_pplns.window_size()
                                          << " chain_len=" << CL_i32 << " build_time=" << ring_us << "us";
                             } else {
-                                // Subsequent shares: find the new deepest entry and slide
-                                // The new PPLNS start is prev_hash (one step deeper)
+                                // Subsequent shares: slide PPLNS window one step deeper.
+                                // The new window drops the shallowest entry and adds the
+                                // share at depth (chain_len - 1) from the new start.
+                                //
+                                // FIX: deep_hash IS the correct new tail entry (at depth
+                                // chain_len-1 from new start). The previous code took
+                                // deep_hash.tail (one step FURTHER), causing an off-by-one
+                                // that shifted the tail entry one position too deep each
+                                // extension — accumulating PPLNS weight errors and causing
+                                // GENTX mismatches for all V36 shares.
                                 auto ring_depth = head_pplns.window_size();
                                 if (ring_depth > 0) {
-                                    // Get the hash one past the current deepest entry
                                     auto deep_hash = chain.get_nth_parent_via_skip(
                                         prev_hash, std::min(ring_depth - 1, CL_i32 - 1));
                                     if (!deep_hash.IsNull() && chain.contains(deep_hash)) {
-                                        auto* deep_idx = chain.get_index(deep_hash);
-                                        auto deeper = deep_idx ? deep_idx->tail : uint256();
-                                        if (!deeper.IsNull() && chain.contains(deeper)) {
-                                            head_pplns.extend_backward(chain, deeper);
-                                        } else {
-                                            // Can't extend — rebuild
-                                            head_pplns.rebuild(chain, prev_hash, CL_i32);
-                                        }
+                                        head_pplns.extend_backward(chain, deep_hash);
                                     } else {
+                                        // Can't extend — rebuild from scratch
                                         head_pplns.rebuild(chain, prev_hash, CL_i32);
                                     }
                                 }
@@ -1753,6 +1755,115 @@ class ShareTracker
         return result;
     }
 
+    // -- Diagnostic: per-share V36 PPLNS walk dump --
+    // Walks from start_hash backward, logging every share's contribution.
+    // Output matches p2pool's [PARENT-PPLNS] stderr format for diff comparison.
+    // Call only from GENTX mismatch handler — never on the hot path.
+    void dump_v36_pplns_walk(const uint256& start_hash, int32_t max_shares)
+    {
+        if (start_hash.IsNull() || !chain.contains(start_hash))
+        {
+            LOG_WARNING << "[PPLNS-WALK] start=" << start_hash.GetHex().substr(0,16)
+                        << " NOT IN CHAIN — walk aborted";
+            return;
+        }
+
+        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(PoolConfig::chain_length() / 4, uint32_t(1));
+        uint64_t decay_per = DECAY_SCALE - (DECAY_SCALE * LN2_MICRO) / (uint64_t(1000000) * half_life);
+
+        int32_t share_count = 0;
+        uint64_t decay_fp = DECAY_SCALE;
+        uint288 running_total;
+        uint288 running_donation;
+        std::map<std::vector<unsigned char>, uint288> per_addr_weight;
+
+        auto height = chain.get_height(start_hash);
+        auto last = chain.get_last(start_hash);
+
+        LOG_WARNING << "[PPLNS-WALK] start=" << start_hash.GetHex().substr(0, 16)
+                    << " max_shares=" << max_shares
+                    << " height=" << height
+                    << " last=" << (last.IsNull() ? "null" : last.GetHex().substr(0, 16))
+                    << " half_life=" << half_life
+                    << " decay_per=" << decay_per;
+
+        auto cur = start_hash;
+        while (!cur.IsNull() && chain.contains(cur) && share_count < max_shares)
+        {
+            chain.get_share(cur).invoke([&](auto* obj) {
+                auto target = chain::bits_to_target(obj->m_bits);
+                auto att = chain::target_to_average_attempts(target);
+                uint32_t don = obj->m_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 script = get_share_script(obj);
+                per_addr_weight[script] += addr_w;
+                running_total += addr_w + don_w;
+                running_donation += don_w;
+
+                // Script hex prefix (first 10 bytes, like p2pool's key.encode('hex')[:40])
+                static const char* HX = "0123456789abcdef";
+                std::string sh;
+                for (size_t i = 0; i < std::min(script.size(), size_t(20)); ++i) {
+                    sh += HX[script[i] >> 4];
+                    sh += HX[script[i] & 0xf];
+                }
+
+                LOG_WARNING << "[PPLNS-WALK]   #" << share_count
+                            << " hash=" << cur.GetHex().substr(0, 16)
+                            << " script=" << sh
+                            << " bits=0x" << std::hex << obj->m_bits << std::dec
+                            << " don=" << don
+                            << " att=" << att.GetLow64()
+                            << " decay_fp=" << decay_fp
+                            << " decayed=" << decayed_att.GetLow64()
+                            << " addr_w=" << addr_w.GetLow64()
+                            << " running=" << running_total.GetLow64();
+            });
+
+            ++share_count;
+
+            decay_fp = mul128_shift(decay_fp, decay_per, DECAY_PRECISION);
+            auto* idx = chain.get_index(cur);
+            cur = idx ? idx->tail : uint256();
+        }
+
+        // Summary matching p2pool's [PARENT-PPLNS] format
+        LOG_WARNING << "[PPLNS-WALK] SUMMARY: shares=" << share_count
+                    << " addrs=" << per_addr_weight.size()
+                    << " total_w=" << running_total.GetLow64()
+                    << " don_w=" << running_donation.GetLow64();
+        for (const auto& [script, weight] : per_addr_weight)
+        {
+            static const char* HX = "0123456789abcdef";
+            std::string sh;
+            for (size_t i = 0; i < std::min(script.size(), size_t(20)); ++i) {
+                sh += HX[script[i] >> 4];
+                sh += HX[script[i] & 0xf];
+            }
+            double pct = running_total.IsNull() ? 0.0 :
+                static_cast<double>(weight.GetLow64()) / static_cast<double>(running_total.GetLow64()) * 100.0;
+            LOG_WARNING << "[PPLNS-WALK]   " << sh
+                        << " w=" << weight.GetLow64()
+                        << " pct=" << std::fixed << std::setprecision(2) << pct << "%";
+        }
+
+        // Chain gap detection: check if walk terminated early (not at chain bottom)
+        if (share_count < max_shares && !cur.IsNull()) {
+            LOG_WARNING << "[PPLNS-WALK] CHAIN GAP: walk stopped at share #" << share_count
+                        << " — next hash " << cur.GetHex().substr(0, 16)
+                        << " is " << (chain.contains(cur) ? "IN chain (walk bug)" : "NOT IN chain (missing share)")
+                        << ". Expected " << max_shares << " shares.";
+        }
+    }
+
     // -- Expected payouts from PPLNS weights --
     // Uses exact integer arithmetic matching generate_share_transaction():
     //   V36: amount = (uint288(subsidy) * weight / total_weight).GetLow64()