fix(eth_capabilities): align with spec — integer retentionBlocks; share Resource helper

Reviewed against ethereum/execution-apis#755 schema and test fixtures:

- DeleteStrategy.RetentionBlocks must be a JSON integer per spec
  ("retentionBlocks":90000), but Nethermind's default long converter writes
  hex. Apply [JsonConverter(typeof(LongRawJsonConverter))] to override.
- Tighten the JSON-schema test: retentionBlocks is integer; deleteStrategy.type
  is enum ["window"] (the spec's only variant — others may be added via oneOf).
- Extract a single Resource(enabled, oldestBlock, deleteStrategy?) helper used
  for all four resources. Enforces the spec invariant "disabled: true ⇒ no
  other fields" in one place.
- Promote HistoryPruner.SlotsPerEpoch from private to public; reference it
  from EthCapabilitiesProvider so the constant has a single source of truth.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: LukaszRozmej

src/Nethermind/Nethermind.History/HistoryPruner.cs

@@ -30,7 +30,7 @@ public class HistoryPruner : IHistoryPruner
 {
     private const int MaxOptimisticSearchAttempts = 3;
     private const int LockWaitTimeoutMs = 100;
-    private const int SlotsPerEpoch = 32;
+    public const int SlotsPerEpoch = 32;
 
     // only one pruning and one searching thread at a time
     private readonly object _pruneLock = new();

src/Nethermind/Nethermind.JsonRpc.Test/Modules/Eth/EthRpcModuleTests.Capabilities.cs

@@ -196,8 +196,8 @@ public async Task eth_capabilities_memory_pruned_reports_window_and_disables_sta
                   "additionalProperties": false,
                   "required": ["type", "retentionBlocks"],
                   "properties": {
-                    "type": { "type": "string" },
-                    "retentionBlocks": { "type": "string", "pattern": "^0x[0-9a-fA-F]+$" }
+                    "type": { "type": "string", "enum": ["window"] },
+                    "retentionBlocks": { "type": "integer", "minimum": 0 }
                   }
                 }
               }

src/Nethermind/Nethermind.JsonRpc/Modules/Eth/EthCapabilities.cs

@@ -3,6 +3,7 @@
 
 using System.Text.Json.Serialization;
 using Nethermind.Core.Crypto;
+using Nethermind.Serialization.Json;
 
 namespace Nethermind.JsonRpc.Modules.Eth;
 
@@ -16,7 +17,7 @@ namespace Nethermind.JsonRpc.Modules.Eth;
 /// <param name="Receipts">Receipt lookup availability (also exposed as <see cref="Tx"/> and <see cref="Logs"/>).</param>
 /// <param name="Blocks">Historical block and header availability.</param>
 /// <param name="Stateproofs">Proof / trie-node availability (eth_getProof depth window).</param>
-public record class EthCapabilities(
+public record EthCapabilities(
     [property: JsonPropertyOrder(0)] ChainHead Head,
     [property: JsonPropertyOrder(1)] ResourceAvailability State,
     [property: JsonPropertyOrder(4)] ResourceAvailability Receipts,
@@ -47,6 +48,8 @@ public readonly record struct ResourceAvailability(
     [property: JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)] DeleteStrategy? DeleteStrategy = null);
 
 /// <summary>Rolling-window deletion strategy for a resource.</summary>
-/// <param name="Type">Strategy type — always <c>"window"</c>.</param>
-/// <param name="RetentionBlocks">Number of recent blocks retained.</param>
-public readonly record struct DeleteStrategy(string Type, long RetentionBlocks);
+/// <param name="Type">Strategy type — currently always <c>"window"</c>; the spec uses <c>oneOf</c> to leave room for future strategies.</param>
+/// <param name="RetentionBlocks">Number of recent blocks retained. Per spec this is a JSON integer (not a hex quantity), so the default Ethereum hex converter is overridden.</param>
+public readonly record struct DeleteStrategy(
+    string Type,
+    [property: JsonConverter(typeof(LongRawJsonConverter))] long RetentionBlocks);

src/Nethermind/Nethermind.JsonRpc/Modules/Eth/EthCapabilitiesProvider.cs

@@ -18,8 +18,6 @@ public class EthCapabilitiesProvider(
     IHistoryConfig? historyConfig = null,
     IHistoryPruner? historyPruner = null) : IEthCapabilitiesProvider
 {
-    private const int SlotsPerEpoch = 32;
-
     public EthCapabilities GetCapabilities()
     {
         BlockHeader? head = blockTree.Head?.Header;
@@ -44,28 +42,35 @@ public EthCapabilities GetCapabilities()
         // historyPruner.OldestBlockHeader.Number; Rolling mode produces a known retention window.
         long historyFloor = historyPruner?.OldestBlockHeader?.Number ?? 0;
         DeleteStrategy? historyWindow = historyConfig?.Pruning == PruningModes.Rolling
-            ? new DeleteStrategy("window", historyConfig.RetentionEpochs * SlotsPerEpoch)
+            ? new DeleteStrategy("window", historyConfig.RetentionEpochs * HistoryPruner.SlotsPerEpoch)
             : null;
 
         return new EthCapabilities(
             Head: new ChainHead(head?.Number ?? 0, head?.Hash ?? Keccak.Zero),
             // State is always available (at minimum the genesis trie exists), even on a memory-pruned
             // node that hasn't yet synced past the first block — in which case OldestBlock is null
             // because the rolling window lower bound cannot yet be computed.
-            State: new ResourceAvailability(
-                Disabled: false,
-                OldestBlock: stateOldest,
-                DeleteStrategy: stateRetention > 0 ? new DeleteStrategy("window", stateRetention.Value) : null),
+            State: Resource(
+                enabled: true,
+                oldestBlock: stateOldest,
+                deleteStrategy: stateRetention > 0 ? new DeleteStrategy("window", stateRetention.Value) : null),
             // Receipts/Tx/Logs share storage and pruning policy in Nethermind — one descriptor covers
             // all three. EthCapabilities.Tx and .Logs are computed properties that alias .Receipts.
-            Receipts: new ResourceAvailability(
-                Disabled: !receiptsSynced,
-                OldestBlock: receiptsSynced ? Math.Max(oldestReceipts, historyFloor) : null,
-                DeleteStrategy: receiptsSynced ? historyWindow : null),
-            Blocks: new ResourceAvailability(
-                Disabled: !headersAvailable,
-                OldestBlock: headersAvailable ? Math.Max(lowestBlock, historyFloor) : null,
-                DeleteStrategy: headersAvailable ? historyWindow : null),
-            Stateproofs: new ResourceAvailability(Disabled: !isArchive, OldestBlock: isArchive ? 0L : null));
+            Receipts: Resource(receiptsSynced, Math.Max(oldestReceipts, historyFloor), historyWindow),
+            Blocks: Resource(headersAvailable, Math.Max(lowestBlock, historyFloor), historyWindow),
+            Stateproofs: Resource(isArchive, 0L));
     }
+
+    /// <summary>
+    /// Builds a single resource descriptor. When <paramref name="enabled"/> is false, the spec
+    /// requires <c>disabled: true</c> with no other fields present — the helper enforces that
+    /// by zeroing <c>OldestBlock</c> and <c>DeleteStrategy</c> regardless of what was passed.
+    /// </summary>
+    private static ResourceAvailability Resource(
+        bool enabled,
+        long? oldestBlock,
+        DeleteStrategy? deleteStrategy = null) =>
+        new(Disabled: !enabled,
+            OldestBlock: enabled ? oldestBlock : null,
+            DeleteStrategy: enabled ? deleteStrategy : null);
 }