In-house discv5

.github/workflows/rpc-comparison.yml

@@ -142,7 +142,7 @@ jobs:
       network: ${{ inputs.network }}
       convert_to_paprika: "${{ inputs.convert_to_paprika }}"
 
-  # Spawn a pruned Geth node via the smoke-tests framework 
+  # Spawn a pruned Geth node via the smoke-tests framework
   create_geth_node:
     name: Spawn pruned Geth node
     uses: ./.github/workflows/run-a-geth-node.yml

Directory.Packages.props

@@ -76,7 +76,6 @@
     <PackageVersion Include="NUnit.Analyzers" Version="4.14.0" />
     <PackageVersion Include="NUnit3TestAdapter" Version="6.2.0" />
     <PackageVersion Include="Open.NAT.Core" Version="2.1.0.5" />
-    <PackageVersion Include="PierTwo.Lantern.Discv5.WireProtocol" Version="1.0.0-preview.8" />
     <PackageVersion Include="Polly" Version="8.6.6" />
     <PackageVersion Include="prometheus-net.AspNetCore" Version="8.2.1" />
     <PackageVersion Include="Prometheus.Client.MetricPusher" Version="3.3.0" />

src/Nethermind/Nethermind.Config/Nethermind.Config.csproj

@@ -7,11 +7,11 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.Caching.Memory" />
     <PackageReference Include="NonBlocking" />
-    <PackageReference Include="PierTwo.Lantern.Discv5.WireProtocol" PrivateAssets="all" />
     <PackageReference Include="System.Configuration.ConfigurationManager" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Nethermind.Core\Nethermind.Core.csproj" />
+    <ProjectReference Include="..\Nethermind.Network.Enr\Nethermind.Network.Enr.csproj" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="..\Chains\**\*.*">

src/Nethermind/Nethermind.Config/NetworkNode.cs

@@ -2,12 +2,9 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
 #nullable enable
-using Lantern.Discv5.Enr;
-using Lantern.Discv5.Enr.Entries;
-using Lantern.Discv5.Enr.Identity;
-using Lantern.Discv5.Enr.Identity.V4;
 using Nethermind.Core.Crypto;
 using Nethermind.Logging;
+using Nethermind.Network.Enr;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
@@ -20,11 +17,8 @@ namespace Nethermind.Config;
 /// </summary>
 public class NetworkNode
 {
-    private static readonly EnrFactory _enrFactory = new(new EnrEntryRegistry());
-    private static readonly IIdentityVerifier identityVerifier = new IdentityVerifierV4();
-
     private readonly Enode? _enode;
-    private readonly Enr? _enr;
+    private readonly NodeRecord? _enr;
 
     [MemberNotNullWhen(true, nameof(Enode))]
     [MemberNotNullWhen(false, nameof(Enr))]
@@ -42,7 +36,7 @@ public NetworkNode(string nodeString)
         }
         else
         {
-            _enr = _enrFactory.CreateFromString(nodeString, identityVerifier);
+            _enr = NodeRecord.FromEnrString(nodeString);
         }
     }
 
@@ -82,7 +76,7 @@ public static NetworkNode[] ParseNodes(string[]? nodeRecords, ILogger logger)
         return [.. nodes];
     }
 
-    public override string ToString() => IsEnode ? Enode.ToString() : Enr.ToString();
+    public override string ToString() => IsEnode ? Enode.ToString() : Enr.EnrString;
 
     public NetworkNode(PublicKey publicKey, string ip, int port, long reputation = 0)
         : this(new Enode(publicKey, IPAddress.Parse(ip), port)) => Reputation = reputation;
@@ -91,11 +85,20 @@ public NetworkNode(PublicKey publicKey, string ip, int port, long reputation = 0
 
     public Enode? Enode => _enode;
 
-    public Enr? Enr => _enr;
+    public NodeRecord? Enr => _enr;
 
-    public PublicKey NodeId => IsEnode ? Enode.PublicKey : new PublicKey(Enr.GetEntry<EntrySecp256K1>(EnrEntryKey.Secp256K1).Value);
-    public string Host => IsEnode ? Enode.HostIp.ToString() : Enr.GetEntry<EntryIp>(EnrEntryKey.Ip).Value.ToString();
-    public IPAddress HostIp => IsEnode ? Enode.HostIp : Enr.GetEntry<EntryIp>(EnrEntryKey.Ip).Value;
-    public int Port => IsEnode ? Enode.Port : Enr.GetEntry<EntryTcp>(EnrEntryKey.Tcp).Value;
+    public PublicKey NodeId => IsEnode ? Enode.PublicKey : GetEnrPublicKey();
+    public string Host => IsEnode ? Enode.HostIp.ToString() : HostIp.ToString();
+    public IPAddress HostIp => IsEnode ? Enode.HostIp : Enr!.DiscoveryIp ?? IPAddress.None;
+    public int Port => IsEnode ? Enode.Port : Enr!.DiscoveryPort ?? 0;
+    public int DiscoveryPort => IsEnode ? Enode.DiscoveryPort : Enr!.DiscoveryPort ?? 0;
     public long Reputation { get; set; }
+
+    private PublicKey GetEnrPublicKey()
+    {
+        CompressedPublicKey publicKey = Enr!.GetObj<CompressedPublicKey>(EnrContentKey.SecP256k1)
+            ?? throw new InvalidOperationException("ENR is missing secp256k1 public key.");
+
+        return publicKey.Decompress();
+    }
 }

src/Nethermind/Nethermind.Core.Test/Caching/LruCacheTests.cs

@@ -235,6 +235,82 @@ public void Can_delete()
             Assert.That(cache.Delete(_addresses[0]), Is.False);
         }
 
+        [Test]
+        public void Can_remove_and_return_value()
+        {
+            LruCache<Address, Account> cache = new(Capacity, "test");
+            cache.Set(_addresses[0], _accounts[0]);
+
+            Assert.That(cache.TryRemove(_addresses[0], out Account? removed), Is.True);
+            Assert.That(removed, Is.EqualTo(_accounts[0]));
+            Assert.That(cache.TryRemove(_addresses[0], out removed), Is.False);
+            Assert.That(removed, Is.Null);
+        }
+
+        [Test]
+        public void Evict_is_called_when_capacity_replaces_oldest()
+        {
+            int evicted = 0;
+            LruCache<int, int> cache = new TestEvictingLruCache<int, int>(2, "test", value => evicted = value);
+
+            cache.Set(1, 10);
+            cache.Set(2, 20);
+            cache.Set(3, 30);
+
+            Assert.That(evicted, Is.EqualTo(10));
+        }
+
+        [Test]
+        public void Evict_is_called_when_existing_value_is_replaced()
+        {
+            int evicted = 0;
+            LruCache<int, int> cache = new TestEvictingLruCache<int, int>(2, "test", value => evicted = value);
+
+            cache.Set(1, 10);
+            cache.Set(1, 11);
+
+            Assert.That(evicted, Is.EqualTo(10));
+            Assert.That(cache.Get(1), Is.EqualTo(11));
+        }
+
+        [Test]
+        public void TryRemove_returns_value_without_calling_evict()
+        {
+            int evicted = 0;
+            LruCache<int, int> cache = new TestEvictingLruCache<int, int>(2, "test", value => evicted = value);
+            cache.Set(1, 10);
+
+            Assert.That(cache.TryRemove(1, out int removed), Is.True);
+
+            Assert.That(removed, Is.EqualTo(10));
+            Assert.That(evicted, Is.Zero);
+        }
+
+        [Test]
+        public void Disposing_cache_disposes_evicted_values()
+        {
+            DisposingLruCache<int, DisposableValue> cache = new(1, "test");
+            DisposableValue evicted = new();
+
+            cache.Set(1, evicted);
+            cache.Set(2, new DisposableValue());
+
+            Assert.That(evicted.IsDisposed, Is.True);
+        }
+
+        [Test]
+        public void Disposing_cache_try_remove_transfers_ownership()
+        {
+            DisposingLruCache<int, DisposableValue> cache = new(1, "test");
+            DisposableValue removed = new();
+            cache.Set(1, removed);
+
+            Assert.That(cache.TryRemove(1, out DisposableValue? actual), Is.True);
+
+            Assert.That(actual, Is.SameAs(removed));
+            Assert.That(removed.IsDisposed, Is.False);
+        }
+
         [Test]
         public void Clear_should_free_all_capacity()
         {
@@ -261,6 +337,29 @@ public void Clear_should_free_all_capacity()
             }
         }
 
+        [TestCase(EvictionOperation.Delete, false)]
+        [TestCase(EvictionOperation.ReplaceExisting, true)]
+        [TestCase(EvictionOperation.ReplaceOldest, false)]
+        [TestCase(EvictionOperation.Clear, false)]
+        public async Task Evict_is_invoked_outside_lock(EvictionOperation operation, bool expectedContainsResult)
+        {
+            LruCache<int, int> cache = null!;
+            TaskCompletionSource<bool> evictResult = new(TaskCreationOptions.RunContinuationsAsynchronously);
+            cache = new TestEvictingLruCache<int, int>(2, "test", _ => evictResult.SetResult(cache.Contains(1)));
+            cache.Set(1, 10);
+            if (operation == EvictionOperation.ReplaceOldest)
+            {
+                cache.Set(2, 20);
+            }
+
+            Task operationTask = Task.Run(() => RunEvictionOperation(cache, operation));
+            Task completedTask = await Task.WhenAny(operationTask, Task.Delay(TimeSpan.FromSeconds(5)));
+
+            Assert.That(completedTask, Is.SameAs(operationTask));
+            await operationTask;
+            Assert.That(await evictResult.Task.WaitAsync(TimeSpan.FromSeconds(5)), Is.EqualTo(expectedContainsResult));
+        }
+
         [Test]
         public void Delete_keeps_internal_structure()
         {
@@ -301,5 +400,50 @@ public void Wrong_capacity_number_at_constructor()
                 });
 
         }
+
+        private static void RunEvictionOperation(LruCache<int, int> cache, EvictionOperation operation)
+        {
+            switch (operation)
+            {
+                case EvictionOperation.Delete:
+                    cache.Delete(1);
+                    return;
+                case EvictionOperation.ReplaceExisting:
+                    cache.Set(1, 11);
+                    return;
+                case EvictionOperation.ReplaceOldest:
+                    cache.Set(3, 30);
+                    return;
+                case EvictionOperation.Clear:
+                    cache.Clear();
+                    return;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(operation), operation, null);
+            }
+        }
+
+        public enum EvictionOperation
+        {
+            Delete,
+            ReplaceExisting,
+            ReplaceOldest,
+            Clear
+        }
+
+        private sealed class TestEvictingLruCache<TKey, TValue>(
+            int maxCapacity,
+            string name,
+            Action<TValue> evict) : LruCache<TKey, TValue>(maxCapacity, name)
+            where TKey : notnull
+        {
+            protected override void Evict(TValue value) => evict(value);
+        }
+
+        private sealed class DisposableValue : IDisposable
+        {
+            public bool IsDisposed { get; private set; }
+
+            public void Dispose() => IsDisposed = true;
+        }
     }
 }

src/Nethermind/Nethermind.Core.Test/Modules/InsecureProtectedPrivateKey.cs

@@ -10,5 +10,5 @@ public class InsecureProtectedPrivateKey(PrivateKey privateKey) : IProtectedPriv
 {
     public PublicKey PublicKey => privateKey.PublicKey;
     public CompressedPublicKey CompressedPublicKey => privateKey.CompressedPublicKey;
-    public PrivateKey Unprotect() => privateKey;
+    public PrivateKey Unprotect() => new(privateKey.KeyBytes);
 }

src/Nethermind/Nethermind.Core.Test/Modules/PseudoNethermindRunner.cs

@@ -83,7 +83,7 @@ public async Task StartDiscovery(CancellationToken cancellationToken)
         await ctx.Resolve<IStaticNodesManager>().InitAsync();
 
         _discoveryApp = ctx.Resolve<IDiscoveryApp>();
-        _ = _discoveryApp.StartAsync(); // Bootstrap is not blocking by default
+        await _discoveryApp.StartAsync();
 
         _peerPool = ctx.Resolve<IPeerPool>();
         _peerPool.Start();

src/Nethermind/Nethermind.Core.Test/Modules/TestEnvironmentModule.cs

@@ -44,7 +44,6 @@ protected override void Load(ContainerBuilder builder)
             // These two don't use the DB provider
             .AddKeyedSingleton<IFullDb>(DbNames.PeersDb, (_) => new MemDb())
             .AddKeyedSingleton<IFullDb>(DbNames.DiscoveryNodes, (_) => new MemDb())
-            .AddKeyedSingleton<IFullDb>(DbNames.DiscoveryV5Nodes, (_) => new MemDb())
             .AddSingleton<IChannelFactory, INetworkConfig>(networkConfig => new LocalChannelFactory(networkGroup ?? nameof(TestEnvironmentModule), networkConfig))
             .AddSingleton(NodeFilter.AcceptAll) // Disable inbound rate limiting for in-memory channels
 

src/Nethermind/Nethermind.Core/Caching/DisposingLruCache.cs

@@ -0,0 +1,23 @@
+// SPDX-FileCopyrightText: 2026 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+
+namespace Nethermind.Core.Caching;
+
+public sealed class DisposingLruCache<TKey, TValue> : LruCache<TKey, TValue>
+    where TKey : notnull
+    where TValue : IDisposable
+{
+    public DisposingLruCache(int maxCapacity, int startCapacity, string name)
+        : base(maxCapacity, startCapacity, name)
+    {
+    }
+
+    public DisposingLruCache(int maxCapacity, string name)
+        : base(maxCapacity, name)
+    {
+    }
+
+    protected override void Evict(TValue value) => value.Dispose();
+}