Address validation: treat RPC errors as Unknown

Introduce AddressValidationResult (Valid/Invalid/Unknown) and replace the simple bool address validation with ValidateAddressDetailedAsync in BitcoinJobManagerBase. Add retry logic (default 3 attempts, 500ms delay) so RPC timeouts/connection errors return Unknown rather than being treated as Invalid. Update BitcoinPool to authorize only on Valid, reject Unknown without banning (logs a warning), and retain ban behavior for explicit Invalid responses. This prevents mis-banning miners due to daemon unresponsiveness.

Author: mraksoll4

src/Miningcore/Blockchain/Bitcoin/AddressValidationResult.cs

@@ -0,0 +1,18 @@
+namespace Miningcore.Blockchain.Bitcoin;
+
+// Result of address validation against the coin daemon.
+// Three states instead of bool: RPC timeout/error is not proof of an
+// invalid address, so it must not collapse into the same "false" as
+// an explicit invalid response from the daemon.
+public enum AddressValidationResult
+{
+    // Daemon confirmed the address is valid.
+    Valid,
+
+    // Daemon confirmed the address is invalid.
+    Invalid,
+
+    // No definitive answer after retries (timeout/connection error).
+    // Must not be treated as Invalid.
+    Unknown
+}

src/Miningcore/Blockchain/Bitcoin/BitcoinJobManagerBase.cs

@@ -230,7 +230,7 @@ protected virtual async Task UpdateNetworkStatsAsync(CancellationToken ct)
                 logger.Warn(() => $"Error(s) refreshing network stats: {string.Join(", ", errors.Select(y => y.Error.Message))}");
 
             // results[0]=GetMiningInfo and results[1]=GetNetworkInfo are mandatory.
-            // results[2]=GetNetworkHashPS is optional — already guarded by the null-check below.
+            // results[2]=GetNetworkHashPS is optional - already guarded by the null-check below.
             if(results[0].Error != null || results[1].Error != null)
                 return;
 
@@ -593,14 +593,46 @@ public override void Configure(PoolConfig pc, ClusterConfig cc)
         base.Configure(pc, cc);
     }
 
-    public virtual async Task<bool> ValidateAddressAsync(string address, CancellationToken ct)
+    // Retry attempts for validateaddress RPC before giving up as Unknown.
+    protected virtual int AddressValidationMaxAttempts => 3;
+
+    // Delay between retry attempts.
+    protected virtual TimeSpan AddressValidationRetryDelay => TimeSpan.FromMilliseconds(500);
+
+    public virtual async Task<AddressValidationResult> ValidateAddressDetailedAsync(string address, CancellationToken ct)
     {
         if(string.IsNullOrEmpty(address))
-            return false;
+            return AddressValidationResult.Invalid;
+
+        for(var attempt = 1; attempt <= AddressValidationMaxAttempts; attempt++)
+        {
+            var result = await rpc.ExecuteAsync<ValidateAddressResponse>(logger, BitcoinCommands.ValidateAddress, ct, new[] { address });
+
+            // RPC succeeded, daemon gave a definitive answer, no retry needed.
+            if(result.Error == null && result.Response != null)
+                return result.Response.IsValid ? AddressValidationResult.Valid : AddressValidationResult.Invalid;
+
+            // RPC failed (timeout/connection error). Not proof address is invalid.
+            logger.Warn(() => $"validateaddress RPC failed for '{address}' (attempt {attempt}/{AddressValidationMaxAttempts}): {result.Error?.Message ?? "no response"}");
+
+            if(attempt < AddressValidationMaxAttempts)
+            {
+                try
+                {
+                    await Task.Delay(AddressValidationRetryDelay, ct);
+                }
+
+                catch(TaskCanceledException)
+                {
+                    break;
+                }
+            }
+        }
 
-        var result = await rpc.ExecuteAsync<ValidateAddressResponse>(logger, BitcoinCommands.ValidateAddress, ct, new[] { address });
+        // All retries failed, no definitive answer from daemon.
+        logger.Warn(() => $"Unable to validate address '{address}' after {AddressValidationMaxAttempts} attempts, daemon unresponsive");
 
-        return result.Response is {IsValid: true};
+        return AddressValidationResult.Unknown;
     }
 
     #endregion // API-Surface

src/Miningcore/Blockchain/Bitcoin/BitcoinPool.cs

@@ -105,7 +105,8 @@ protected virtual async Task OnAuthorizeAsync(StratumConnection connection, Time
         var workerName = split?.Skip(1).FirstOrDefault()?.Trim() ?? string.Empty;
 
         // assumes that minerName is an address
-        context.IsAuthorized = await manager.ValidateAddressAsync(minerName, ct);
+        var addressValidationResult = await manager.ValidateAddressDetailedAsync(minerName, ct);
+        context.IsAuthorized = addressValidationResult == AddressValidationResult.Valid;
         context.Miner = minerName;
         context.Worker = workerName;
 
@@ -160,8 +161,20 @@ protected virtual async Task OnAuthorizeAsync(StratumConnection connection, Time
 			await connection.NotifyAsync(BitcoinStratumMethods.SetDifficulty, new object[] { context.Difficulty });
         }
 
+        else if(addressValidationResult == AddressValidationResult.Unknown)
+        {
+            // Daemon did not respond after retries, not proof address is bad.
+            // Reject without ban so a valid miner can just reconnect.
+            logger.Warn(() => $"[{connection.ConnectionId}] Could not validate address '{minerName}' (daemon unresponsive), rejecting without ban");
+
+            await connection.RespondErrorAsync(StratumError.UnauthorizedWorker, "Address validation temporarily unavailable, please retry", request.Id, context.IsAuthorized);
+
+            Disconnect(connection);
+        }
+
         else
         {
+            // Daemon explicitly confirmed the address is invalid, safe to ban.
             await connection.RespondErrorAsync(StratumError.UnauthorizedWorker, "Authorization failed", request.Id, context.IsAuthorized);
 
             if(clusterConfig?.Banning?.BanOnLoginFailure is null or true)