Feature - EIP-4444 EraE Support

src/Nethermind/Nethermind.Core/BlockHeaderProof.cs

@@ -0,0 +1,22 @@
+// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+using Nethermind.Core.Crypto;
+
+namespace Nethermind.Core;
+
+public enum BlockHeaderProofType : byte
+{
+    BlockProofHistoricalHashesAccumulator = 0,
+    BlockProofHistoricalRoots = 1,
+    BlockProofHistoricalSummaries = 2
+}
+
+public record BlockHeaderProof
+{
+    public BlockHeaderProofType? ProofType { get; init; }
+    public ValueHash256[]? HashesAccumulator { get; init; }
+    public ValueHash256[]? BeaconBlockProof { get; init; }
+    public ValueHash256[]? ExecutionBlockProof { get; init; }
+    public ValueHash256? BeaconBlockRoot { get; init; }
+    public long? Slot { get; init; }
+}

src/Nethermind/Nethermind.Era1/AccumulatorCalculator.cs

@@ -1,7 +1,9 @@
 // SPDX-FileCopyrightText: 2023 Demerzel Solutions Limited
 // SPDX-License-Identifier: LGPL-3.0-only
 
+using System.Buffers.Binary;
 using System.Runtime.InteropServices;
+using System.Security.Cryptography;
 using Nethermind.Core.Collections;
 using Nethermind.Core.Crypto;
 using Nethermind.Int256;
@@ -10,16 +12,21 @@
 namespace Nethermind.Era1;
 
 // https://github.com/ethereum/portal-network-specs/blob/master/history/history-network.md#algorithms
-internal class AccumulatorCalculator : IDisposable
+public class AccumulatorCalculator : IDisposable
 {
+    private const int TreeDepth = 13;   // log2(8192)
+    private const int ProofLength = 15; // 1 (HeaderRecord field) + 13 (tree) + 1 (length mixin)
+
     private readonly ArrayPoolList<ReadOnlyMemory<byte>> _roots = new(EraWriter.MaxEra1Size);
+    private readonly ArrayPoolList<UInt256> _totalDifficulties = new(EraWriter.MaxEra1Size);
 
     public void Add(Hash256 headerHash, UInt256 td)
     {
         Merkleizer merkleizer = new(Merkle.NextPowerOfTwoExponent(2));
         merkleizer.Feed(headerHash.Bytes);
         merkleizer.Feed(td);
         _roots.Add(merkleizer.CalculateRoot().ToLittleEndian());
+        _totalDifficulties.Add(td);
     }
 
     public ValueHash256 ComputeRoot()
@@ -30,7 +37,56 @@ public ValueHash256 ComputeRoot()
         return new ValueHash256(MemoryMarshal.Cast<UInt256, byte>(MemoryMarshal.CreateSpan(ref root, 1)));
     }
 
-    internal void Clear() => _roots.Clear();
+    public ValueHash256[] GetProof(int blockIndex)
+    {
+        if (blockIndex < 0 || blockIndex >= _roots.Count)
+            throw new ArgumentOutOfRangeException(nameof(blockIndex), $"Block index {blockIndex} is out of range [0, {_roots.Count - 1}].");
+
+        int count = _roots.Count;
+        ValueHash256[] proof = new ValueHash256[ProofLength];
+
+        // Level 0: sibling of block_hash = total_difficulty as 32-byte LE SSZ chunk
+        proof[0] = new ValueHash256(_totalDifficulties[blockIndex].ToLittleEndian());
+
+        // Build the flat binary tree over MaxEra1Size HeaderRecord roots.
+        byte[] flatTree = new byte[2 * EraWriter.MaxEra1Size * 32];
+        for (int i = 0; i < count; i++)
+            _roots[i].Span.CopyTo(flatTree.AsSpan((EraWriter.MaxEra1Size + i) * 32, 32));
+
+        Span<byte> combined = stackalloc byte[64];
+        for (int i = EraWriter.MaxEra1Size - 1; i >= 1; i--)
+        {
+            ReadOnlySpan<byte> left = flatTree.AsSpan(2 * i * 32, 32);
+            ReadOnlySpan<byte> right = flatTree.AsSpan((2 * i + 1) * 32, 32);
+            left.CopyTo(combined);
+            right.CopyTo(combined[32..]);
+            SHA256.TryHashData(combined, flatTree.AsSpan(i * 32, 32), out _);
+        }
+
+        int current = EraWriter.MaxEra1Size + blockIndex;
+        for (int i = 0; i < TreeDepth; i++)
+        {
+            int sibling = current ^ 1;
+            proof[1 + i] = new ValueHash256(flatTree.AsSpan(sibling * 32, 32));
+            current >>= 1;
+        }
+
+        Span<byte> lenBytes = stackalloc byte[32];
+        BinaryPrimitives.WriteUInt64LittleEndian(lenBytes, (ulong)count);
+        proof[14] = new ValueHash256(lenBytes);
 
-    public void Dispose() => _roots.Dispose();
+        return proof;
+    }
+
+    internal void Clear()
+    {
+        _roots.Clear();
+        _totalDifficulties.Clear();
+    }
+
+    public void Dispose()
+    {
+        _roots.Dispose();
+        _totalDifficulties.Dispose();
+    }
 }

src/Nethermind/Nethermind.Era1/E2StoreReader.cs

@@ -167,16 +167,18 @@ public long BlockCount
         }
     }
 
-    public ValueHash256 CalculateChecksum()
+    public ValueHash256 CalculateChecksum() => ComputeChecksum(_file, _fileLength);
+
+    public static ValueHash256 ComputeChecksum(SafeFileHandle file, long fileLength)
     {
         using IncrementalHash sha = IncrementalHash.CreateHash(HashAlgorithmName.SHA256);
         const int bufferSize = 81920;
         byte[] buffer = new byte[bufferSize];
         long offset = 0;
-        while (offset < _fileLength)
+        while (offset < fileLength)
         {
-            int toRead = (int)Math.Min(bufferSize, _fileLength - offset);
-            int read = RandomAccess.Read(_file, buffer.AsSpan(0, toRead), offset);
+            int toRead = (int)Math.Min(bufferSize, fileLength - offset);
+            int read = RandomAccess.Read(file, buffer.AsSpan(0, toRead), offset);
             if (read == 0) break;
             sha.AppendData(buffer, 0, read);
             offset += read;

src/Nethermind/Nethermind.EraE.Test/Admin/AdminEraServiceTests.cs

@@ -0,0 +1,93 @@
+// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using Nethermind.Config;
+using Nethermind.Core;
+using Nethermind.EraE.Admin;
+using Nethermind.EraE.Export;
+using Nethermind.EraE.Import;
+using Nethermind.JsonRpc;
+using Nethermind.Logging;
+using NSubstitute;
+using NUnit.Framework;
+
+namespace Nethermind.EraE.Test.Admin;
+
+public class AdminEraServiceTests
+{
+    [Test]
+    public void ImportHistory_WhenCalled_DelegatesToImporter()
+    {
+        IEraImporter importer = Substitute.For<IEraImporter>();
+        AdminEraService sut = new(
+            importer,
+            Substitute.For<IEraExporter>(),
+            Substitute.For<IProcessExitSource>(),
+            LimboLogs.Instance);
+
+        sut.ImportHistory("somewhere", 99, 999, null);
+
+        importer.Received().Import("somewhere", 99, 999, null, Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public void ImportHistory_WhenImportAlreadyRunning_ReturnsFailure()
+    {
+        IEraImporter importer = Substitute.For<IEraImporter>();
+        TaskCompletionSource tcs = new();
+        importer.Import("somewhere", 99, 999, null, Arg.Any<CancellationToken>()).Returns(tcs.Task);
+
+        AdminEraService sut = new(
+            importer,
+            Substitute.For<IEraExporter>(),
+            Substitute.For<IProcessExitSource>(),
+            LimboLogs.Instance);
+
+        sut.ImportHistory("somewhere", 99, 999, null);
+
+        ResultWrapper<string> result = sut.ImportHistory("somewhere", 99, 999, null);
+        Assert.That(result.Result.ResultType, Is.EqualTo(ResultType.Failure));
+
+        tcs.TrySetResult();
+
+        Assert.That(() => sut.ImportHistory("somewhere", 99, 999, null), Throws.Nothing);
+    }
+
+    [Test]
+    public void ExportHistory_WhenCalled_DelegatesToExporter()
+    {
+        IEraExporter exporter = Substitute.For<IEraExporter>();
+        AdminEraService sut = new(
+            Substitute.For<IEraImporter>(),
+            exporter,
+            Substitute.For<IProcessExitSource>(),
+            LimboLogs.Instance);
+
+        sut.ExportHistory("somewhere", 99, 999);
+
+        exporter.Received().Export("somewhere", 99, 999, Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public void ExportHistory_WhenExportAlreadyRunning_ReturnsFailure()
+    {
+        IEraExporter exporter = Substitute.For<IEraExporter>();
+        TaskCompletionSource tcs = new();
+        exporter.Export("somewhere", 99, 999, Arg.Any<CancellationToken>()).Returns(tcs.Task);
+
+        AdminEraService sut = new(
+            Substitute.For<IEraImporter>(),
+            exporter,
+            Substitute.For<IProcessExitSource>(),
+            LimboLogs.Instance);
+
+        sut.ExportHistory("somewhere", 99, 999);
+
+        ResultWrapper<string> result = sut.ExportHistory("somewhere", 99, 999);
+        Assert.That(result.Result.ResultType, Is.EqualTo(ResultType.Failure));
+
+        tcs.TrySetResult();
+
+        Assert.That(() => sut.ExportHistory("somewhere", 99, 999), Throws.Nothing);
+    }
+}

src/Nethermind/Nethermind.EraE.Test/Archive/AccumulatorCalculatorTests.cs

@@ -0,0 +1,154 @@
+// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using Nethermind.Core;
+using Nethermind.Core.Crypto;
+using Nethermind.Core.Specs;
+using Nethermind.Core.Test.Builders;
+using AccumulatorCalculator = Nethermind.Era1.AccumulatorCalculator;
+using Nethermind.EraE.Proofs;
+using Nethermind.Int256;
+using NSubstitute;
+using NUnit.Framework;
+
+namespace Nethermind.EraE.Test.Archive;
+
+public class AccumulatorCalculatorTests
+{
+    [Test]
+    public void Add_WhenCalled_DoesNotThrow()
+    {
+        using AccumulatorCalculator sut = new();
+        Assert.That(() => sut.Add(Keccak.Zero, 0), Throws.Nothing);
+    }
+
+    [Test]
+    public void ComputeRoot_WithKnownValues_ReturnsExpectedResult()
+    {
+        using AccumulatorCalculator sut = new();
+        sut.Add(Keccak.Zero, 1);
+        sut.Add(Keccak.MaxValue, 2);
+
+        byte[] result = sut.ComputeRoot().ToByteArray();
+
+        Assert.That(result, Is.EquivalentTo(new byte[]
+        {
+            0x3E, 0xD6, 0x26, 0x52, 0xDF, 0xB7, 0xE1, 0x07,
+            0x2D, 0x0F, 0x04, 0x0F, 0xEB, 0x6D, 0x00, 0x2A,
+            0x9F, 0x7C, 0xE3, 0x7C, 0xF8, 0xDD, 0xB1, 0x65,
+            0x49, 0xA7, 0xAC, 0x5C, 0xF8, 0xE3, 0xB7, 0x91
+        }));
+    }
+
+    [Test]
+    public void ComputeRoot_WithSameInputInTwoInstances_ReturnsSameResult()
+    {
+        using AccumulatorCalculator sut1 = new();
+        using AccumulatorCalculator sut2 = new();
+
+        sut1.Add(Keccak.Zero, 100);
+        sut2.Add(Keccak.Zero, 100);
+
+        Assert.That(sut1.ComputeRoot(), Is.EqualTo(sut2.ComputeRoot()));
+    }
+
+    [Test]
+    public void ComputeRoot_WithDifferentInputs_ReturnsDifferentResults()
+    {
+        using AccumulatorCalculator sut1 = new();
+        using AccumulatorCalculator sut2 = new();
+
+        sut1.Add(Keccak.Zero, 1);
+        sut2.Add(Keccak.MaxValue, 1);
+
+        Assert.That(sut1.ComputeRoot(), Is.Not.EqualTo(sut2.ComputeRoot()));
+    }
+
+    [Test]
+    public void GetProof_WithNegativeIndex_ThrowsArgumentOutOfRangeException()
+    {
+        using AccumulatorCalculator sut = new();
+        sut.Add(Keccak.Zero, 1);
+
+        Assert.That(() => sut.GetProof(-1), Throws.TypeOf<ArgumentOutOfRangeException>());
+    }
+
+    [Test]
+    public void GetProof_WithIndexAtCount_ThrowsArgumentOutOfRangeException()
+    {
+        using AccumulatorCalculator sut = new();
+        sut.Add(Keccak.Zero, 1);
+
+        Assert.That(() => sut.GetProof(1), Throws.TypeOf<ArgumentOutOfRangeException>());
+    }
+
+    [Test]
+    public void GetProof_WhenCalled_Returns15Elements()
+    {
+        using AccumulatorCalculator sut = new();
+        sut.Add(Keccak.Zero, 42);
+
+        Assert.That(sut.GetProof(0), Has.Length.EqualTo(15));
+    }
+
+    [TestCase(0)]
+    [TestCase(1)]
+    [TestCase(7)]
+    public void GetProof_WhenCalled_ProofZeroIsTotalDifficultyLE(int blockIndex)
+    {
+        using AccumulatorCalculator sut = new();
+        for (int i = 0; i <= blockIndex; i++)
+            sut.Add(Keccak.Zero, (ulong)(i + 1));
+
+        byte[] expected = new byte[32];
+        expected[0] = (byte)(blockIndex + 1);
+        Assert.That(sut.GetProof(blockIndex)[0].ToByteArray(), Is.EqualTo(expected));
+    }
+
+    [TestCase(0, 1)]
+    [TestCase(0, 3)]
+    [TestCase(2, 5)]
+    public Task GetProof_WhenValidatedByValidator_Succeeds(int blockIndex, int totalBlocks)
+    {
+        Block[] blocks = Enumerable.Range(0, totalBlocks)
+            .Select(i => Build.A.Block
+                .WithNumber(i)
+                .WithTotalDifficulty((UInt256)(i * 100 + 1))
+                .TestObject)
+            .ToArray();
+
+        using AccumulatorCalculator sut = new();
+        for (int i = 0; i < totalBlocks; i++)
+            sut.Add(blocks[i].Hash!, blocks[i].TotalDifficulty!.Value);
+
+        ValueHash256 root = sut.ComputeRoot();
+        ValueHash256[] proof = sut.GetProof(blockIndex);
+
+        Validator validator = BuildValidator(root);
+        BlockHeaderProof headerProof = new() { ProofType = BlockHeaderProofType.BlockProofHistoricalHashesAccumulator, HashesAccumulator = proof };
+
+        Assert.That(async () => await validator.VerifyContent(blocks[blockIndex], headerProof), Throws.Nothing);
+        return Task.CompletedTask;
+    }
+
+    [Test]
+    public void GetProof_WithDifferentIndices_ReturnDifferentProofs()
+    {
+        using AccumulatorCalculator sut = new();
+        sut.Add(Keccak.Zero, 1);
+        sut.Add(Keccak.MaxValue, 2);
+
+        ValueHash256[] proof0 = sut.GetProof(0);
+        ValueHash256[] proof1 = sut.GetProof(1);
+
+        Assert.That(proof0[0], Is.Not.EqualTo(proof1[0]));
+        Assert.That(proof0[1], Is.Not.EqualTo(proof1[1]));
+    }
+
+    private static Validator BuildValidator(ValueHash256 trustedRoot)
+    {
+        ISpecProvider specProvider = Substitute.For<ISpecProvider>();
+        specProvider.BeaconChainGenesisTimestamp.Returns((ulong?)1606824023UL);
+        return new Validator(specProvider, new List<ValueHash256> { trustedRoot }, null, null);
+    }
+}