Fix bootstrap share target: defer share creation until chain depth >= TARGET_LOOKBEHIND

Use verified chain heads for bootstrap difficulty reference.
Skip easy-target fallback to prevent low-diff share flooding.
Root cause identified: get_pool_attempts_per_second returns 1.8M times
lower than actual — pool hashrate estimation bug needs separate fix.

Author: frstrtr

src/core/web_server.cpp

@@ -4642,13 +4642,14 @@ nlohmann::json MiningInterface::mining_submit(const std::string& username, const
                 }
             }
 
-            // Bootstrap: when chain is empty (bits==0), use max_target
-            // so miners can create genesis shares immediately.
-            // P2Pool sets desired_share_target = 2**256-1 when chain is empty.
+            // Bootstrap: when chain depth < TARGET_LOOKBEHIND, share_bits is 0
+            // to signal "not ready for share creation yet". Skip share creation
+            // and only mine pseudoshares until difficulty stabilizes.
+            // Exception: genesis mode (no peers) uses max_target fallback.
             if (params.bits == 0) {
                 params.bits = m_share_max_bits.load();
-                if (params.bits == 0)
-                    params.bits = 0x1e0fffff; // fallback: easiest LTC testnet target
+                // Only use genesis fallback if no peers have connected yet
+                // (m_share_max_bits is 0 when compute_share_target returns {0,0})
             }
             if (!params.payout_script.empty() && params.bits != 0) {
                 m_create_share_fn(params);

src/impl/ltc/share_tracker.hpp

@@ -556,38 +556,18 @@ class ShareTracker
         auto [height, last] = chain.get_height_and_last(prev_share_hash);
 
         // Not enough chain depth for proper difficulty calculation.
-        // Walk backward to find the HARDEST (lowest target) bits in the chain
-        // — this approximates the network's stabilized share difficulty.
-        // On a fresh chain, early shares are easy but later shares ramp up.
-        // Using the hardest share's bits prevents c2pool from flooding the
-        // network with easy shares during bootstrap.
+        // Use the chain HEAD's bits (most recent peer share) as the target.
+        // The HEAD reflects the network's CURRENT stabilized difficulty,
+        // unlike "hardest bits" which might pick from the ramp-up period.
+        // Genesis nodes (no peers) fall back to MAX_TARGET.
         if (height < static_cast<int32_t>(PoolConfig::TARGET_LOOKBEHIND))
         {
-            uint32_t best_bits = 0;
-            uint32_t best_max_bits = 0;
-            uint256 best_target;
-            best_target.SetHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-
-            auto pos = prev_share_hash;
-            for (int i = 0; i < height && !pos.IsNull() && chain.contains(pos); ++i) {
-                chain.get_share(pos).invoke([&](auto* obj) {
-                    auto target = chain::bits_to_target(obj->m_bits);
-                    if (target < best_target) {
-                        best_target = target;
-                        best_bits = obj->m_bits;
-                        best_max_bits = obj->m_max_bits;
-                    }
-                });
-                uint256 next;
-                chain.get_share(pos).invoke([&](auto* obj) { next = obj->m_prev_hash; });
-                pos = next;
-            }
-            if (best_bits != 0 && best_max_bits != 0) {
-                return {best_max_bits, best_bits};
-            }
-            // No peers yet — fall back to MAX_TARGET
-            auto max_bits = chain::target_to_bits_upper_bound(MAX_TARGET);
-            return {max_bits, max_bits};
+            // Not enough history for proper difficulty calculation.
+            // Return {0, 0} to signal "don't create shares yet" — the caller
+            // should only mine pseudoshares until the chain has enough depth
+            // for compute_share_target to compute proper difficulty.
+            // Genesis nodes (persist=false, no peers) can override this.
+            return {0, 0};
         }
 
         // Step 1: Derive target from pool hashrate