Add Eof Execution EIP-7692 (EIP-663, EIP-3540, EIP-3670, EIP-4200, EIP-4750, EIP-5450, EIP-6206, EIP-7069, EIP-7480, EIP-7620, EIP-7698, EIP-7756)

src/Nethermind/Directory.Packages.props

@@ -13,6 +13,7 @@
     <PackageVersion Include="BouncyCastle.Cryptography" Version="2.5.0" />
     <PackageVersion Include="Ckzg.Bindings" Version="2.0.1.1258" />
     <PackageVersion Include="Colorful.Console" Version="1.2.15" />
+    <PackageVersion Include="CommandLineParser" Version="2.9.1" />
     <PackageVersion Include="CommunityToolkit.HighPerformance" Version="8.3.2" />
     <PackageVersion Include="ConcurrentHashSet" Version="1.3.0" />
     <PackageVersion Include="coverlet.collector" Version="6.0.3" />

src/Nethermind/Ethereum.Basic.Test/TransactionTests.cs

@@ -7,7 +7,6 @@
 using System.IO;
 using System.Linq;
 using System.Numerics;
-using System.Text.Json.Serialization;
 
 using Ethereum.Test.Base;
 using Nethermind.Core;

src/Nethermind/Ethereum.Blockchain.Pyspec.Test/Ethereum.Blockchain.Pyspec.Test.csproj

@@ -4,11 +4,11 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
     <PackageReference Include="coverlet.collector">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" />
     <PackageReference Include="NUnit" />
     <PackageReference Include="NUnit.Analyzers">
       <PrivateAssets>all</PrivateAssets>

src/Nethermind/Ethereum.Blockchain.Pyspec.Test/LoadPyspecTestsStrategy.cs

@@ -15,6 +15,12 @@ namespace Ethereum.Blockchain.Pyspec.Test;
 
 public class LoadPyspecTestsStrategy : ITestLoadStrategy
 {
+    private enum TestType
+    {
+        Blockchain,
+        GeneralState,
+        Eof
+    }
     public string ArchiveVersion { get; init; } = Constants.DEFAULT_ARCHIVE_VERSION;
     public string ArchiveName { get; init; } = Constants.DEFAULT_ARCHIVE_NAME;
 
@@ -23,11 +29,16 @@ public IEnumerable<IEthereumTest> Load(string testsDir, string wildcard = null)
         string testsDirectoryName = Path.Combine(AppContext.BaseDirectory, "PyTests", ArchiveVersion, ArchiveName.Split('.')[0]);
         if (!Directory.Exists(testsDirectoryName)) // Prevent redownloading the fixtures if they already exists with this version and archive name
             DownloadAndExtract(ArchiveVersion, ArchiveName, testsDirectoryName);
-        bool isStateTest = testsDir.Contains("state_tests", StringComparison.InvariantCultureIgnoreCase);
+        TestType testType = testsDir.Contains("state_tests", StringComparison.InvariantCultureIgnoreCase)
+            ? TestType.GeneralState
+            : testsDir.Contains("eof_tests", StringComparison.InvariantCultureIgnoreCase)
+            ? TestType.Eof
+            : TestType.Blockchain;
+
         IEnumerable<string> testDirs = !string.IsNullOrEmpty(testsDir)
             ? Directory.EnumerateDirectories(Path.Combine(testsDirectoryName, testsDir), "*", new EnumerationOptions { RecurseSubdirectories = true })
             : Directory.EnumerateDirectories(testsDirectoryName, "*", new EnumerationOptions { RecurseSubdirectories = true });
-        return testDirs.SelectMany(td => LoadTestsFromDirectory(td, wildcard, isStateTest));
+        return testDirs.SelectMany(td => LoadTestsFromDirectory(td, wildcard, testType));
     }
 
     private void DownloadAndExtract(string archiveVersion, string archiveName, string testsDirectoryName)
@@ -44,7 +55,7 @@ private void DownloadAndExtract(string archiveVersion, string archiveName, strin
         TarFile.ExtractToDirectory(gzStream, testsDirectoryName, true);
     }
 
-    private IEnumerable<IEthereumTest> LoadTestsFromDirectory(string testDir, string wildcard, bool isStateTest)
+    private IEnumerable<IEthereumTest> LoadTestsFromDirectory(string testDir, string wildcard, TestType testType)
     {
         List<IEthereumTest> testsByName = new();
         IEnumerable<string> testFiles = Directory.EnumerateFiles(testDir);
@@ -54,20 +65,28 @@ private IEnumerable<IEthereumTest> LoadTestsFromDirectory(string testDir, string
             FileTestsSource fileTestsSource = new(testFile, wildcard);
             try
             {
-                IEnumerable<IEthereumTest> tests = isStateTest
-                    ? fileTestsSource.LoadGeneralStateTests()
-                    : fileTestsSource.LoadBlockchainTests();
+                IEnumerable<IEthereumTest> tests = testType switch
+                {
+                    TestType.Eof => fileTestsSource.LoadEofTests(),
+                    TestType.GeneralState => fileTestsSource.LoadGeneralStateTests(),
+                    _ => fileTestsSource.LoadBlockchainTests()
+                };
+
                 foreach (IEthereumTest test in tests)
                 {
-                    test.Category = testDir;
+                    test.Category ??= testDir;
                 }
                 testsByName.AddRange(tests);
             }
             catch (Exception e)
             {
-                IEthereumTest failedTest = isStateTest
-                    ? new GeneralStateTest()
-                    : new BlockchainTest();
+                IEthereumTest failedTest = testType switch
+                {
+                    TestType.Eof => new EofTest(),
+                    TestType.GeneralState => new GeneralStateTest(),
+                    _ => new BlockchainTest()
+                };
+
                 failedTest.Name = testDir;
                 failedTest.LoadFailure = $"Failed to load: {e}";
                 testsByName.Add(failedTest);

src/Nethermind/Ethereum.Blockchain.Pyspec.Test/OsakaBlockChainTests.cs

@@ -0,0 +1,31 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Ethereum.Test.Base;
+using NUnit.Framework;
+
+namespace Ethereum.Blockchain.Pyspec.Test;
+
+[TestFixture]
+[Parallelizable(ParallelScope.All)]
+[Explicit("These tests are not yet updated to devnet-6")]
+public class OsakaBlockChainTests : BlockchainTestBase
+{
+    [TestCaseSource(nameof(LoadTests))]
+    public async Task Test(BlockchainTest test) => await RunTest(test);
+
+    private static IEnumerable<TestCaseData> LoadTests()
+    {
+        TestsSourceLoader loader = new(new LoadPyspecTestsStrategy()
+        {
+            ArchiveName = "fixtures_eip7692.tar.gz",
+            ArchiveVersion = "[email protected]"
+        }, $"fixtures/blockchain_tests/osaka");
+        return loader.LoadTests().OfType<BlockchainTest>().Select(t => new TestCaseData(t)
+            .SetName(t.Name)
+            .SetCategory(t.Category));
+    }
+}

src/Nethermind/Ethereum.Blockchain.Pyspec.Test/OsakaEofTests.cs

@@ -0,0 +1,29 @@
+// SPDX-FileCopyrightText: 2023 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System.Collections.Generic;
+using System.Linq;
+using Ethereum.Test.Base;
+using NUnit.Framework;
+
+namespace Ethereum.Blockchain.Pyspec.Test;
+
+[TestFixture]
+[Parallelizable(ParallelScope.All)]
+public class OsakaEofTests : EofTestBase
+{
+    [TestCaseSource(nameof(LoadTests))]
+    public void Test(EofTest test) => RunCITest(test);
+
+    private static IEnumerable<TestCaseData> LoadTests()
+    {
+        TestsSourceLoader loader = new(new LoadPyspecTestsStrategy()
+        {
+            ArchiveName = "fixtures_eip7692.tar.gz",
+            ArchiveVersion = "[email protected]"
+        }, $"fixtures/eof_tests/osaka");
+        return loader.LoadTests().Cast<EofTest>().Select(t => new TestCaseData(t)
+            .SetName(t.Name)
+            .SetCategory(t.Category));
+    }
+}

src/Nethermind/Ethereum.Blockchain.Pyspec.Test/OsakaStateTests.cs

@@ -0,0 +1,30 @@
+// SPDX-FileCopyrightText: 2023 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System.Collections.Generic;
+using System.Linq;
+using Ethereum.Test.Base;
+using FluentAssertions;
+using NUnit.Framework;
+
+namespace Ethereum.Blockchain.Pyspec.Test;
+
+[TestFixture]
+[Parallelizable(ParallelScope.All)]
+public class OsakaStateTests : GeneralStateTestBase
+{
+    [TestCaseSource(nameof(LoadTests))]
+    public void Test(GeneralStateTest test) => RunTest(test).Pass.Should().BeTrue();
+
+    private static IEnumerable<TestCaseData> LoadTests()
+    {
+        TestsSourceLoader loader = new(new LoadPyspecTestsStrategy()
+        {
+            ArchiveName = "fixtures_eip7692.tar.gz",
+            ArchiveVersion = "[email protected]"
+        }, $"fixtures/state_tests/osaka");
+        return loader.LoadTests().Cast<GeneralStateTest>().Select(t => new TestCaseData(t)
+            .SetName(t.Name)
+            .SetCategory(t.Category));
+    }
+}

src/Nethermind/Ethereum.Blockchain.Test/BadOpcodeTests.cs

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
 using System.Collections.Generic;
-using System.Linq;
 using Ethereum.Test.Base;
 using NUnit.Framework;
 

src/Nethermind/Ethereum.Blockchain.Test/EofTests.cs

@@ -1,27 +1,36 @@
 // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
 // SPDX-License-Identifier: LGPL-3.0-only
 
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using Ethereum.Test.Base;
 using NUnit.Framework;
 
 namespace Ethereum.Blockchain.Test;
 
 [TestFixture]
 [Parallelizable(ParallelScope.All)]
+[Explicit("Legacy ethereum/tests EOF tests currently are based on a Prague spec, which lacks EOF.")]
 public class EOFTests : GeneralStateTestBase
 {
-    // Uncomment when EOF tests are merged
-
-    // [TestCaseSource(nameof(LoadTests))]
-    // public void Test(GeneralStateTest test)
-    // {
-    //     Assert.That(RunTest(test).Pass, Is.True);
-    // }
+    [TestCaseSource(nameof(LoadTests))]
+    public void Test(GeneralStateTest test)
+    {
+        // Legacy ethereum/tests EOF tests currently are based on a Prague spec, which lacks EOF.
+        // All EOF tests are now a part of EEST
+        //Assert.That(RunTest(test).Pass, Is.True);
+    }
 
     public static IEnumerable<GeneralStateTest> LoadTests()
     {
-        var loader = new TestsSourceLoader(new LoadEipTestsStrategy(), "stEOF");
-        return (IEnumerable<GeneralStateTest>)loader.LoadTests();
+        return [];
+
+        //var eip3540Loader = (IEnumerable<GeneralStateTest>)(new TestsSourceLoader(new LoadEofTestsStrategy(), "stEIP3540").LoadTests());
+        //var eip3670Loader = (IEnumerable<GeneralStateTest>)(new TestsSourceLoader(new LoadEofTestsStrategy(), "stEIP3670").LoadTests());
+        //var eip4200Loader = (IEnumerable<GeneralStateTest>)(new TestsSourceLoader(new LoadEofTestsStrategy(), "stEIP4200").LoadTests());
+        //var eip4750Loader = (IEnumerable<GeneralStateTest>)(new TestsSourceLoader(new LoadEofTestsStrategy(), "stEIP4750").LoadTests());
+        //var eip5450Loader = (IEnumerable<GeneralStateTest>)(new TestsSourceLoader(new LoadEofTestsStrategy(), "stEIP5450").LoadTests());
+        //return eip3540Loader.Concat(eip3670Loader).Concat(eip4200Loader).Concat(eip4750Loader).Concat(eip5450Loader);
     }
 }

src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs

@@ -38,8 +38,7 @@ namespace Ethereum.Test.Base;
 
 public abstract class BlockchainTestBase
 {
-    private static InterfaceLogger _logger = new NUnitLogger(LogLevel.Trace);
-    // private static ILogManager _logManager = new OneLoggerLogManager(_logger);
+    private static InterfaceLogger _logger = new NUnitLogger(LogLevel.Info);
     private static ILogManager _logManager = LimboLogs.Instance;
     private static ISealValidator Sealer { get; }
     private static DifficultyCalculatorWrapper DifficultyCalculator { get; }

src/Nethermind/Ethereum.Test.Base/EofTest.cs

@@ -0,0 +1,31 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using Ethereum.Test.Base.Interfaces;
+using Nethermind.Evm.EvmObjectFormat;
+
+namespace Ethereum.Test.Base;
+public class Result
+{
+    public string Fork { get; set; }
+    public bool Success { get; set; }
+    public string? Error { get; set; }
+}
+
+public class VectorTest
+{
+    public byte[] Code { get; set; }
+    public ValidationStrategy ContainerKind { get; set; }
+}
+
+public class EofTest : IEthereumTest
+{
+    public string Name { get; set; }
+    public VectorTest Vector { get; set; }
+    public string? Category { get; set; }
+    public string? LoadFailure { get; set; }
+    public Result Result { get; internal set; }
+    public string? Description { get; set; }
+    public string? Url { get; set; }
+    public string? Spec { get; set; }
+}

src/Nethermind/Ethereum.Test.Base/EofTestBase.cs

@@ -0,0 +1,77 @@
+// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using Nethermind.Evm;
+using Nethermind.Evm.Tracing;
+using Nethermind.Logging;
+using NUnit.Framework;
+using Nethermind.Evm.EvmObjectFormat;
+
+namespace Ethereum.Test.Base
+{
+    public abstract class EofTestBase
+    {
+        private static ILogger _logger = new(TextContextLogger.Instance);
+        private static ILogManager _logManager = new TestLogManager(LogLevel.Warn);
+
+        [SetUp]
+        public void Setup()
+        {
+            EofValidator.Logger = _logger;
+        }
+
+        protected static void Setup(ILogManager logManager)
+        {
+            _logManager = logManager ?? LimboLogs.Instance;
+            _logger = _logManager.GetClassLogger();
+        }
+
+        protected void RunCITest(EofTest test)
+        {
+            var result = RunTest(test, NullTxTracer.Instance);
+
+            if (result != test.Result.Success)
+            {
+                _logger.Info($"Spec: {test.Spec}");
+                _logger.Info(test.Description);
+                _logger.Info($"Url: {test.Url}");
+            }
+
+            Assert.That(result, Is.EqualTo(test.Result.Success));
+        }
+
+        protected bool RunTest(EofTest test)
+        {
+            return RunTest(test, NullTxTracer.Instance) == test.Result.Success;
+        }
+
+        protected bool RunTest(EofTest test, ITxTracer txTracer)
+        {
+            TestContext.Out.WriteLine($"Running {test.Name} at {DateTime.UtcNow:HH:mm:ss.ffffff}");
+            Assert.That(test.LoadFailure, Is.Null, "test data loading failure");
+
+            var vector = test.Vector;
+            var code = vector.Code;
+            var strategy = vector.ContainerKind;
+            var fork = test.Result.Fork switch
+            {
+                "Osaka" => Nethermind.Specs.Forks.Osaka.Instance,
+                "Prague" => Nethermind.Specs.Forks.Prague.Instance,
+                "Berlin" => Nethermind.Specs.Forks.Berlin.Instance,
+                "London" => Nethermind.Specs.Forks.London.Instance,
+                "Shanghai" => Nethermind.Specs.Forks.Shanghai.Instance,
+                "Constantinople" => Nethermind.Specs.Forks.Constantinople.Instance,
+                "Byzantium" => Nethermind.Specs.Forks.Byzantium.Instance,
+                "SpuriousDragon" => Nethermind.Specs.Forks.SpuriousDragon.Instance,
+                "TangerineWhistle" => Nethermind.Specs.Forks.TangerineWhistle.Instance,
+                "Homestead" => Nethermind.Specs.Forks.Homestead.Instance,
+                "Frontier" => Nethermind.Specs.Forks.Frontier.Instance,
+                _ => throw new NotSupportedException($"Fork {test.Result.Fork} is not supported")
+            };
+
+            bool result = CodeDepositHandler.IsValidWithEofRules(fork, code, 1, strategy);
+            return result;
+        }
+    }
+}