Fix merged PPLNS hash: remove desired_weight cap from compute_merged_payout_hash

Multiple interrelated fixes for c2pool↔p2pool V36 consensus:

1. merged_payout_hash: walk VERIFIED chain only (not raw chain) to exclude
   c2pool's own unverified shares from the weight computation. Defer check
   until verified depth >= CHAIN_LENGTH to avoid bootstrap false positives.

2. desired_target: pass MAX_TARGET instead of block difficulty to
   compute_share_target(). Block difficulty made shares 2634x too hard.
   The [pre_target3//30, pre_target3] clipping provides the correct range.

3. Bootstrap share target: use hardest (lowest target) bits from received
   peer shares instead of MAX_TARGET during bootstrap. Prevents flooding
   the network with easy shares when joining an existing chain.

4. Add /miner_thresholds API endpoint: returns minimum viable hashrate,
   minimum payout per share, pool hashrate, and DUST range for dashboard.

5. Remove single-address merged coinbase fallback (submitauxblock path) —
   always use multi-address PPLNS block builder.

Author: frstrtr

src/c2pool/c2pool_refactored.cpp

@@ -2056,8 +2056,12 @@ int main(int argc, char* argv[]) {
                     params.donation = static_cast<uint16_t>(std::round(65535.0 * dev_donation / 100.0));
                     params.desired_version = 36;
 
-                    // Compute pool-level share target from tracker state
-                    auto desired_target = chain::bits_to_target(bits);
+                    // Compute pool-level share target from tracker state.
+                    // Pass MAX_TARGET as desired_target so compute_share_target
+                    // clips to pool share difficulty (pre_target3). Block difficulty
+                    // is NOT the share target — it would make shares 1000x+ too hard.
+                    // Per-miner difficulty adjustment happens via VARDIFF in stratum.
+                    auto desired_target = ltc::PoolConfig::max_target();
                     auto [share_max_bits, share_bits] = p2p_node->tracker().compute_share_target(
                         params.prev_share, timestamp, desired_target);
                     params.max_bits = share_max_bits;
@@ -2125,7 +2129,7 @@ int main(int argc, char* argv[]) {
 
                         // Recompute share target with the clipped timestamp
                         {
-                            auto desired_target2 = chain::bits_to_target(bits);
+                            auto desired_target2 = ltc::PoolConfig::max_target();
                             auto [sm, sb] = tracker.compute_share_target(
                                 params.prev_share, params.timestamp, desired_target2);
                             params.max_bits = sm;

src/c2pool/merged/merged_mining.cpp

@@ -769,27 +769,11 @@ void MergedMiningManager::try_submit_merged_blocks(
             proof.index,
             parent_header_hex);
 
-        if (chain.config.multiaddress && m_payout_provider) {
-            // Strategy: submit via BOTH paths for maximum reliability.
-            //
-            // 1. submitauxblock FIRST (fast path) — uses daemon/adapter template,
-            //    arrives instantly because daemon already has the block ready.
-            //    The mm-adapter builds PPLNS coinbase, so payouts are correct.
-            //
-            // 2. submitblock SECOND (THE commitment path) — uses our custom
-            //    coinbase with /c2pool/ tag + THE state_root. If #1 already
-            //    won, this gets "duplicate" (harmless). If #1 failed, this
-            //    is the backup. If this wins the race, the block carries
-            //    our THE commitment on-chain.
-            //
-            // Both are valid blocks with identical PoW. The daemon picks
-            // whichever arrives first. Different scriptSig text doesn't
-            // invalidate the block — it just changes the merkle_root.
-
-            // Fast path: submitauxblock (daemon template)
-            submit_aux_and_relay(chain, auxpow, parent_hash.GetHex());
-
-            // THE commitment path: build custom block with /c2pool/ + state_root
+        // Always use the PPLNS multiaddress path with /c2pool/ tag +
+        // THE state_root + COMBINED_DONATION_SCRIPT marker.
+        // Even solo mode gets proper donation marker and fee outputs.
+        // submitauxblock is never used — it bypasses our coinbase builder.
+        if (m_payout_provider) {
             auto payouts = m_payout_provider(chain.config.chain_id,
                                              chain.current_work.coinbase_value);
             uint256 state_root;
@@ -799,19 +783,20 @@ void MergedMiningManager::try_submit_merged_blocks(
                     chain.current_work.block_template, payouts, auxpow, state_root);
                 if (!block_hex.empty()) {
                     LOG_INFO << "[MM:" << chain.config.symbol
-                             << "] THE block submitted (" << block_hex.size()/2 << " bytes, "
+                             << "] PPLNS block submitted (" << block_hex.size()/2 << " bytes, "
                              << payouts.size() << " outputs, /c2pool/ + state_root)";
                     chain.rpc->submit_block(block_hex);
-                    // Relay custom block via P2P too
                     if (m_block_relay_fn) {
                         try { m_block_relay_fn(chain.config.chain_id, block_hex); }
                         catch (...) {}
                     }
                 }
             }
         } else {
-            LOG_INFO << "[MM:" << chain.config.symbol << "] Single-address mode (multiaddress="
-                     << chain.config.multiaddress << " payout_provider=" << !!m_payout_provider << ")";
+            // No payout provider — cannot build coinbase. Use daemon template
+            // as absolute last resort (no PPLNS, no donation marker).
+            LOG_WARNING << "[MM:" << chain.config.symbol
+                        << "] No payout_provider — falling back to submitauxblock (no PPLNS)";
             submit_aux_and_relay(chain, auxpow, parent_hash.GetHex());
         }
         LOG_INFO << "[MM:" << chain.config.symbol << "] Post-submission processing complete";

src/core/web_server.cpp

@@ -266,6 +266,8 @@ void HttpSession::process_request()
             // ── p2pool legacy compatibility endpoints ──────────────────────
             else if (target == "/local_stats")
                 rest_result = mining_interface_->rest_local_stats();
+            else if (target == "/miner_thresholds")
+                rest_result = mining_interface_->rest_miner_thresholds();
             else if (target == "/web/version")
                 rest_result = mining_interface_->rest_web_version();
             else if (target == "/web/currency_info")
@@ -2387,6 +2389,64 @@ nlohmann::json MiningInterface::rest_stratum_stats()
     return result;
 }
 
+nlohmann::json MiningInterface::rest_miner_thresholds()
+{
+    nlohmann::json result = nlohmann::json::object();
+
+    // Get pool hashrate from global_stats computation
+    auto gs = rest_global_stats();
+    double pool_hr = gs.value("pool_hash_rate", 0.0);
+
+    // Get block subsidy from cached GBT template
+    uint64_t subsidy = 156250000; // default 1.5625 LTC
+    if (m_cached_template.contains("coinbasevalue"))
+        subsidy = m_cached_template.value("coinbasevalue", subsidy);
+
+    // Network params (testnet defaults, overridden by config)
+    uint32_t chain_length = 400;  // REAL_CHAIN_LENGTH
+    uint32_t share_period = 4;    // SHARE_PERIOD
+    if (m_node) {
+        auto hs = m_node->get_hashrate_stats();
+        if (hs.contains("chain_length"))
+            chain_length = hs.value("chain_length", chain_length);
+        if (hs.contains("share_period"))
+            share_period = hs.value("share_period", share_period);
+    }
+
+    double window_sec = static_cast<double>(chain_length) * share_period;
+
+    // min_hashrate = pool_hashrate / chain_length (1 share per window)
+    double min_hr_normal = pool_hr / chain_length;
+    double min_hr_dust = min_hr_normal / 30.0; // 30x DUST range
+
+    // min_payout = subsidy / chain_length
+    double min_payout = static_cast<double>(subsidy) / 1e8 / chain_length;
+
+    result["pool_hashrate"] = pool_hr;
+    result["min_hashrate_normal"] = min_hr_normal;
+    result["min_hashrate_dust"] = min_hr_dust;
+    result["min_payout_ltc"] = min_payout;
+    result["block_subsidy_ltc"] = static_cast<double>(subsidy) / 1e8;
+    result["chain_length"] = chain_length;
+    result["share_period"] = share_period;
+    result["window_seconds"] = window_sec;
+    result["dust_range"] = 30;
+
+    // Human-readable formatting
+    auto fmt_hr = [](double hr) -> std::string {
+        char buf[32];
+        if (hr >= 1e12) { snprintf(buf, sizeof(buf), "%.2f TH/s", hr / 1e12); return buf; }
+        if (hr >= 1e9)  { snprintf(buf, sizeof(buf), "%.2f GH/s", hr / 1e9);  return buf; }
+        if (hr >= 1e6)  { snprintf(buf, sizeof(buf), "%.2f MH/s", hr / 1e6);  return buf; }
+        if (hr >= 1e3)  { snprintf(buf, sizeof(buf), "%.2f KH/s", hr / 1e3);  return buf; }
+        snprintf(buf, sizeof(buf), "%.0f H/s", hr); return buf;
+    };
+    result["min_hashrate_display"] = fmt_hr(min_hr_dust);
+    result["pool_hashrate_display"] = fmt_hr(pool_hr);
+
+    return result;
+}
+
 nlohmann::json MiningInterface::rest_global_stats()
 {
     // Return p2pool-compatible pool statistics

src/core/web_server.hpp

@@ -168,6 +168,7 @@ class MiningInterface : public jsonrpccxx::JsonRpc2Server
     nlohmann::json rest_uptime();
     nlohmann::json rest_connected_miners();
     nlohmann::json rest_stratum_stats();
+    nlohmann::json rest_miner_thresholds();
     nlohmann::json rest_global_stats();
     nlohmann::json rest_sharechain_stats();
     nlohmann::json rest_sharechain_window();