1 files changed, 40 insertions, 0 deletions

diff --git a/src/rpc.cpp b/src/rpc.cpp
index f1a7153..23e25ef 100644
--- a/src/rpc.cpp
+++ b/src/rpc.cpp
@@ -2484,6 +2484,26 @@ static const double VARDIFF_MAX               = 1e12;
 static const int64  VARDIFF_STALL_SECS        = 45;  // 3x share target -- reacts faster without false-triggering on normal variance
 static const double VARDIFF_STALL_CUT         = 4.0; // divide difficulty by this much
 
+// #7: m->hashRate is an EWMA sampled only when a share arrives, so a miner
+// that stops hashing keeps its last estimate forever and RefreshStats sums
+// it into the announced pool total for as long as the connection sits open
+// -- the published pool hashrate ran several times over ground truth
+// because of exactly this. The decay pass in PoolEventLoop applies this
+// policy: a miner gets a grace of HASHRATE_IDLE_MISSES expected share
+// intervals (expected interval = expected hashes per share at its current
+// difficulty / its last rate estimate) with no share, then its estimate
+// decays with a half-life of one more such interval, computed from
+// absolute time so the result does not depend on how often the loop ticks.
+// The interval is clamped to [HASHRATE_MIN_INTERVAL, HASHRATE_MAX_INTERVAL]
+// so a fast miner at the vardiff floor (expected interval of milliseconds)
+// is not punished for ordinary share-delivery jitter, and a very slow
+// miner's grace does not stretch past the point where its estimate means
+// anything. At the vardiff target of one share per 15s, a stopped miner's
+// announced rate is gone within minutes.
+static const double HASHRATE_IDLE_MISSES  = 4.0;    // grace, in expected share intervals
+static const double HASHRATE_MIN_INTERVAL = 1.0;    // seconds; floor for the expected interval
+static const double HASHRATE_MAX_INTERVAL = 3600.0; // seconds; ceiling for the expected interval
+
 struct Miner {
     btf_socket_t fd;
     bool         authorised    = false;
@@ -4900,6 +4920,26 @@ static void PoolEventLoop()
             }
         }
 
+        // 3.6. Hashrate decay (#7) -- see the policy comment at
+        // HASHRATE_IDLE_MISSES. The EWMA is only re-sampled on share arrival,
+        // so without this pass a miner that stops hashing keeps its last
+        // estimate forever and the summed pool hashrate RefreshStats (and
+        // the nostr announcement built from it) publishes is fiction.
+        for (Miner* m : gMiners) {
+            if (m->hashRate <= 0.0 || m->lastShareTime <= 0) continue;
+            double expected = ExpectedHashesForDifficulty(m->difficulty) /
+                              std::max(m->hashRate, 1e-9);
+            if (expected < HASHRATE_MIN_INTERVAL) expected = HASHRATE_MIN_INTERVAL;
+            if (expected > HASHRATE_MAX_INTERVAL) expected = HASHRATE_MAX_INTERVAL;
+            double silent = (double)(GetTime() - m->lastShareTime);
+            double grace  = HASHRATE_IDLE_MISSES * expected;
+            if (silent <= grace) continue;
+            // Half-life of one expected interval past the grace period.
+            // Written off absolute time, not per-tick, so the decay curve is
+            // the same however often this loop runs.
+            m->hashRate *= pow(0.5, (silent - grace) / expected);
+        }
+
         // 4. Select over miner sockets
         if (!gMiners.empty()) {
             fd_set fds; FD_ZERO(&fds);