Fix sync constants from LTC/DOGE daemon source code

Tip age gate: 24 hours (86400s), not 2 hours (7200s).
  Reference: litecoin/src/validation.h DEFAULT_MAX_TIP_AGE = 24*60*60
  Reference: dogecoin/src/validation.h DEFAULT_MAX_TIP_AGE = 24*60*60

Mining gate depth: maturity + reorg buffer, not maturity alone.
  LTC: 100 (COINBASE_MATURITY) + 6 (PEGOUT_MATURITY) = 106
  DOGE: 240 (nCoinbaseMaturity) + 10 (reorg safety) = 250

All constants now reference LTC/DOGE daemon source, not Bitcoin.

Author: frstrtr

src/c2pool/c2pool_refactored.cpp

@@ -1389,15 +1389,18 @@ int main(int argc, char* argv[]) {
                 // Reference: litecoin/src/consensus/consensus.h COINBASE_MATURITY = 100
                 if (ltc_utxo_cache) {
                     auto* cache_ptr = ltc_utxo_cache.get();
-                    constexpr uint32_t LTC_MATURITY = core::coin::LTC_LIMITS.coinbase_maturity;
-                    embedded_node->set_utxo_ready_fn([cache_ptr, LTC_MATURITY]() {
+                    // Mining gate: coinbase_maturity + reorg_buffer
+                    // LTC: 100 + 6 (pegout maturity) = 106
+                    // Reference: litecoin/src/consensus/consensus.h
+                    constexpr uint32_t LTC_GATE = core::coin::LTC_MINING_GATE_DEPTH; // 106
+                    embedded_node->set_utxo_ready_fn([cache_ptr, LTC_GATE]() {
                         auto connected = cache_ptr->blocks_connected();
-                        bool ready = connected >= LTC_MATURITY;
+                        bool ready = connected >= LTC_GATE;
                         if (!ready) {
                             static int s_log_ctr = 0;
                             if (s_log_ctr++ % 20 == 0)
                                 LOG_INFO << "[EMB-LTC] UTXO maturity gate: blocks_connected="
-                                         << connected << " need>=" << LTC_MATURITY;
+                                         << connected << " need>=" << LTC_GATE;
                         }
                         return ready;
                     });
@@ -3551,15 +3554,18 @@ int main(int argc, char* argv[]) {
                             // Reference: dogecoin/src/chainparams.cpp digishieldConsensus.nCoinbaseMaturity = 240
                             if (doge_utxo_cache) {
                                 auto* cache_ptr = doge_utxo_cache.get();
-                                constexpr uint32_t DOGE_MATURITY = core::coin::DOGE_LIMITS.coinbase_maturity;
-                                backend->embedded_node().set_utxo_ready_fn([cache_ptr, DOGE_MATURITY]() {
+                                // Mining gate: coinbase_maturity + reorg_buffer
+                                // DOGE: 240 + 10 (reorg safety) = 250
+                                // Reference: dogecoin/src/chainparams.cpp digishieldConsensus
+                                constexpr uint32_t DOGE_GATE = core::coin::DOGE_MINING_GATE_DEPTH; // 250
+                                backend->embedded_node().set_utxo_ready_fn([cache_ptr, DOGE_GATE]() {
                                     auto connected = cache_ptr->blocks_connected();
-                                    bool ready = connected >= DOGE_MATURITY;
+                                    bool ready = connected >= DOGE_GATE;
                                     if (!ready) {
                                         static int s_log_ctr = 0;
                                         if (s_log_ctr++ % 20 == 0)
                                             LOG_INFO << "[EMB-DOGE] UTXO maturity gate: blocks_connected="
-                                                     << connected << " need>=" << DOGE_MATURITY;
+                                                     << connected << " need>=" << DOGE_GATE;
                                     }
                                     return ready;
                                 });

src/core/coin/utxo.hpp

@@ -50,6 +50,19 @@ static constexpr ChainLimits DOGE_LIMITS = {1'000'000'000'000'000'000LL, 240, 0}
 static constexpr uint32_t LTC_MIN_BLOCKS_TO_KEEP  = 288;
 static constexpr uint32_t DOGE_MIN_BLOCKS_TO_KEEP = 1440;
 
+/// Minimum UTXO depth before mining can start: coinbase_maturity + reorg_buffer.
+/// LTC: 100 (COINBASE_MATURITY) + 6 (PEGOUT_MATURITY reorg depth) = 106
+/// DOGE: 240 (nCoinbaseMaturity post-DigiShield) + 10 (reorg safety) = 250
+/// Reference: litecoin/src/consensus/consensus.h, dogecoin/src/chainparams.cpp
+static constexpr uint32_t LTC_MINING_GATE_DEPTH  = LTC_LIMITS.coinbase_maturity + LTC_LIMITS.pegout_maturity; // 106
+static constexpr uint32_t DOGE_MINING_GATE_DEPTH = DOGE_LIMITS.coinbase_maturity + 10; // 250
+
+/// Tip age threshold for considering chain synced (seconds).
+/// Both LTC and DOGE use 24 hours (86400s) as DEFAULT_MAX_TIP_AGE.
+/// Reference: litecoin/src/validation.h  DEFAULT_MAX_TIP_AGE = 24 * 60 * 60
+/// Reference: dogecoin/src/validation.h  DEFAULT_MAX_TIP_AGE = 24 * 60 * 60
+static constexpr uint32_t DEFAULT_MAX_TIP_AGE = 24 * 60 * 60; // 86400s
+
 /// Check if a value is within the valid money range for a chain.
 /// Reference: LTC/DOGE amount.h MoneyRange()
 inline bool money_range(int64_t v, const ChainLimits& lim) {

src/impl/doge/coin/header_chain.hpp

@@ -11,6 +11,7 @@
 
 #include <impl/ltc/coin/block.hpp>
 #include <impl/doge/coin/chain_params.hpp>
+#include <core/coin/utxo.hpp>  // DEFAULT_MAX_TIP_AGE
 
 #include <core/uint256.hpp>
 #include <core/leveldb_store.hpp>
@@ -371,18 +372,17 @@ class HeaderChain {
         return m_headers.count(prev_hash) > 0;
     }
 
-    /// Whether the chain is synced (tip timestamp within 2 hours of wall clock).
-    /// The 2-hour (7200s) threshold matches Bitcoin Core's IsInitialBlockDownload()
-    /// check (chainparams.h nMaxTipAge). p2pool uses the same gate implicitly:
-    /// getblocktemplate() fails until the daemon considers itself synced.
+    /// Whether the chain is synced (tip timestamp within DEFAULT_MAX_TIP_AGE of wall clock).
+    /// Both litecoind and dogecoind use 24 hours (86400s) as DEFAULT_MAX_TIP_AGE.
+    /// Reference: dogecoin/src/validation.h  DEFAULT_MAX_TIP_AGE = 24 * 60 * 60
     bool is_synced() const {
         std::lock_guard<std::mutex> lock(m_mutex);
         if (m_tip.IsNull()) return false;
         auto it = m_headers.find(m_tip);
         if (it == m_headers.end()) return false;
         auto now = static_cast<uint32_t>(std::time(nullptr));
         uint32_t age = now - it->second.header.m_timestamp;
-        bool synced = age < 7200; // 2 hours
+        bool synced = age < core::coin::DEFAULT_MAX_TIP_AGE; // 24 hours (86400s)
         // Log state changes (throttled via static)
         static bool s_last_synced = false;
         if (synced != s_last_synced) {

src/impl/ltc/coin/header_chain.hpp

@@ -7,6 +7,7 @@
 /// Persistence via LevelDB for fast restarts.
 
 #include "block.hpp"
+#include <core/coin/utxo.hpp>  // DEFAULT_MAX_TIP_AGE
 
 #include <core/uint256.hpp>
 #include <core/leveldb_store.hpp>
@@ -536,18 +537,19 @@ class HeaderChain {
         return m_headers.count(prev_hash) > 0;
     }
 
-    /// Whether the chain is synced (tip timestamp within 2 hours of wall clock).
-    /// The 2-hour (7200s) threshold matches Bitcoin Core's IsInitialBlockDownload()
-    /// check (chainparams.h nMaxTipAge). p2pool uses the same gate implicitly:
-    /// getblocktemplate() fails until litecoind considers itself synced.
+    /// Whether the chain is synced (tip timestamp within DEFAULT_MAX_TIP_AGE of wall clock).
+    /// Both litecoind and dogecoind use 24 hours (86400s) as DEFAULT_MAX_TIP_AGE.
+    /// Reference: litecoin/src/validation.h  DEFAULT_MAX_TIP_AGE = 24 * 60 * 60
+    /// p2pool uses the same gate implicitly: getblocktemplate() fails until
+    /// litecoind considers itself synced (tip within nMaxTipAge).
     bool is_synced() const {
         std::lock_guard<std::mutex> lock(m_mutex);
         if (m_tip.IsNull()) return false;
         auto it = m_headers.find(m_tip);
         if (it == m_headers.end()) return false;
         auto now = static_cast<uint32_t>(std::time(nullptr));
         uint32_t age = now - it->second.header.m_timestamp;
-        bool synced = age < 7200; // 2 hours
+        bool synced = age < core::coin::DEFAULT_MAX_TIP_AGE; // 24 hours (86400s)
         // Log state changes (throttled via static)
         static bool s_last_synced = false;
         if (synced != s_last_synced) {