Other Lru keys types

src/Nethermind/Nethermind.AuRa.Test/Transactions/TxPermissionFilterTest.cs

@@ -250,7 +250,7 @@ public bool allows_transactions_before_transitions(long blockNumber)
             VersionedTransactionPermissionContract transactionPermissionContract = new(AbiEncoder.Instance,
                 TestItem.AddressA,
                 5,
-                Substitute.For<IReadOnlyTxProcessorSource>(), new LruCache<Keccak, UInt256>(100, "TestCache"),
+                Substitute.For<IReadOnlyTxProcessorSource>(), new LruCache<KeccakKey, UInt256>(100, "TestCache"),
                 LimboLogs.Instance,
                 Substitute.For<ISpecProvider>());
 
@@ -263,7 +263,7 @@ public class TestTxPermissionsBlockchain : TestContractBlockchain
             public PermissionBasedTxFilter PermissionBasedTxFilter { get; private set; }
             public PermissionBasedTxFilter.Cache TxPermissionFilterCache { get; private set; }
 
-            public LruCache<Keccak, UInt256> TransactionPermissionContractVersions { get; private set; }
+            public LruCache<KeccakKey, UInt256> TransactionPermissionContractVersions { get; private set; }
 
             protected override BlockProcessor CreateBlockProcessor()
             {
@@ -274,7 +274,7 @@ protected override BlockProcessor CreateBlockProcessor()
                 };
 
                 TransactionPermissionContractVersions =
-                    new LruCache<Keccak, UInt256>(PermissionBasedTxFilter.Cache.MaxCacheSize, nameof(TransactionPermissionContract));
+                    new LruCache<KeccakKey, UInt256>(PermissionBasedTxFilter.Cache.MaxCacheSize, nameof(TransactionPermissionContract));
 
                 IReadOnlyTrieStore trieStore = new TrieStore(DbProvider.StateDb, LimboLogs.Instance).AsReadOnly();
                 IReadOnlyTxProcessorSource txProcessorSource = new ReadOnlyTxProcessingEnv(

src/Nethermind/Nethermind.Blockchain/BlockTree.cs

@@ -53,8 +53,8 @@ private readonly LruCache<KeccakKey, Block>
         private readonly IDb _blockInfoDb;
         private readonly IDb _metadataDb;
 
-        private readonly LruCache<Keccak, Block> _invalidBlocks =
-            new LruCache<Keccak, Block>(128, 128, "invalid blocks");
+        private readonly LruCache<KeccakKey, Block> _invalidBlocks =
+            new(128, 128, "invalid blocks");
 
         private readonly BlockDecoder _blockDecoder = new();
         private readonly HeaderDecoder _headerDecoder = new();

src/Nethermind/Nethermind.Consensus.AuRa/AuRaContractGasLimitOverride.cs

@@ -98,7 +98,7 @@ public class Cache
         {
             private const int MaxCacheSize = 10;
 
-            internal LruCache<Keccak, long?> GasLimitCache { get; } = new LruCache<Keccak, long?>(MaxCacheSize, "BlockGasLimit");
+            internal LruCache<KeccakKey, long?> GasLimitCache { get; } = new(MaxCacheSize, "BlockGasLimit");
         }
 
         public bool IsGasLimitValid(BlockHeader parentHeader, in long gasLimit, out long? expectedGasLimit)

src/Nethermind/Nethermind.Consensus.AuRa/Contracts/VersionedContract.cs

@@ -20,10 +20,10 @@ public abstract class VersionedContract<T> : IActivatedAtBlock where T : IVersio
         private readonly IDictionary<UInt256, T> _versions;
 
         private readonly IVersionedContract _versionSelectorContract;
-        private readonly LruCache<Keccak, UInt256> _versionsCache;
+        private readonly LruCache<KeccakKey, UInt256> _versionsCache;
         private readonly ILogger _logger;
 
-        protected VersionedContract(IDictionary<UInt256, T> versions, LruCache<Keccak, UInt256> cache, long activation, ILogManager logManager)
+        protected VersionedContract(IDictionary<UInt256, T> versions, LruCache<KeccakKey, UInt256> cache, long activation, ILogManager logManager)
         {
             _versions = versions ?? throw new ArgumentNullException(nameof(versions));
             _versionSelectorContract = versions.Values.Last();

src/Nethermind/Nethermind.Consensus.AuRa/Contracts/VersionedTransactionPermissionContract.cs

@@ -21,7 +21,7 @@ public VersionedTransactionPermissionContract(IAbiEncoder abiEncoder,
             Address contractAddress,
             long activation,
             IReadOnlyTxProcessorSource readOnlyTxProcessorSource,
-            LruCache<Keccak, UInt256> cache,
+            LruCache<KeccakKey, UInt256> cache,
             ILogManager logManager,
             ISpecProvider specProvider)
             : base(

src/Nethermind/Nethermind.Consensus.AuRa/InitializationSteps/AuRaNethermindApi.cs

@@ -26,8 +26,8 @@ public class AuRaNethermindApi : NethermindApi
 
         public IValidatorStore? ValidatorStore { get; set; }
 
-        public LruCache<Keccak, UInt256> TransactionPermissionContractVersions { get; }
-            = new LruCache<Keccak, UInt256>(
+        public LruCache<KeccakKey, UInt256> TransactionPermissionContractVersions { get; }
+            = new(
                 PermissionBasedTxFilter.Cache.MaxCacheSize,
                 nameof(TransactionPermissionContract));
 

src/Nethermind/Nethermind.Merge.Plugin/InvalidChainTracker/InvalidChainTracker.cs

@@ -25,7 +25,7 @@ public class InvalidChainTracker : IInvalidChainTracker
     private readonly IBlockFinder _blockFinder;
     private readonly IBlockCacheService _blockCacheService;
     private readonly ILogger _logger;
-    private readonly LruCache<Keccak, Node> _tree;
+    private readonly LruCache<KeccakKey, Node> _tree;
 
     // CompositeDisposable only available on System.Reactive. So this will do for now.
     private readonly List<Action> _disposables = new();
@@ -38,7 +38,7 @@ public InvalidChainTracker(
     {
         _poSSwitcher = poSSwitcher;
         _blockFinder = blockFinder;
-        _tree = new LruCache<Keccak, Node>(1024, nameof(InvalidChainTracker));
+        _tree = new(1024, nameof(InvalidChainTracker));
         _logger = logManager.GetClassLogger<InvalidChainTracker>();
         _blockCacheService = blockCacheService;
     }

src/Nethermind/Nethermind.State/Witnesses/WitnessCollector.cs

@@ -22,7 +22,7 @@ public class WitnessCollector : IWitnessCollector, IWitnessRepository
         [ThreadStatic]
         private static bool _collectWitness;
 
-        private readonly LruCache<Keccak, Keccak[]> _witnessCache = new(256, "Witnesses");
+        private readonly LruCache<KeccakKey, Keccak[]> _witnessCache = new(256, "Witnesses");
 
         public IReadOnlyCollection<Keccak> Collected => _collected;
 

src/Nethermind/Nethermind.TxPool/TxPool.cs

@@ -579,7 +579,7 @@ public void Dispose()
         private static void AddNodeInfoEntryForTxPool()
         {
             ThisNodeInfo.AddInfo("Mem est tx   :",
-                $"{(LruCache<Keccak, object>.CalculateMemorySize(32, MemoryAllowance.TxHashCacheSize) + LruCache<Keccak, Transaction>.CalculateMemorySize(4096, MemoryAllowance.MemPoolSize)) / 1000 / 1000}MB"
+                $"{(LruCache<KeccakKey, object>.CalculateMemorySize(32, MemoryAllowance.TxHashCacheSize) + LruCache<Keccak, Transaction>.CalculateMemorySize(4096, MemoryAllowance.MemPoolSize)) / 1000 / 1000}MB"
                     .PadLeft(8));
         }
     }