Add Eof Execution context

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/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/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-osaka.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/PragueStateTests.cs → src/Nethermind/Ethereum.Blockchain.Pyspec.Test/OsakaStateTests.cs

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: 2023 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
 using System.Collections.Generic;
 using System.Linq;
 using Ethereum.Test.Base;
@@ -9,14 +12,18 @@ namespace Ethereum.Blockchain.Pyspec.Test;
 [TestFixture]
 [Parallelizable(ParallelScope.All)]
 [Explicit("These tests are not ready yet")]
-public class PragueStateTests : GeneralStateTestBase
+public class OsakaStateTests : GeneralStateTestBase
 {
     [TestCaseSource(nameof(LoadTests))]
     public void Test(GeneralStateTest test) => RunTest(test).Pass.Should().BeTrue();
 
     private static IEnumerable<GeneralStateTest> LoadTests()
     {
-        TestsSourceLoader loader = new(new LoadPyspecTestsStrategy(), $"fixtures/state_tests/prague");
+        TestsSourceLoader loader = new(new LoadPyspecTestsStrategy()
+        {
+            ArchiveName = "fixtures_eip7692-osaka.tar.gz",
+            ArchiveVersion = "[email protected]"
+        }, $"fixtures/state_tests/osaka");
         return loader.LoadTests().Cast<GeneralStateTest>();
     }
 }

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

@@ -0,0 +1,25 @@
+// 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 ready yet")]
+public class PragueBlockChainTests : BlockchainTestBase
+{
+    [TestCaseSource(nameof(LoadTests))]
+    public async Task Test(BlockchainTest test) => await RunTest(test);
+
+    private static IEnumerable<BlockchainTest> LoadTests()
+    {
+        TestsSourceLoader loader = new(new LoadPyspecTestsStrategy(), $"fixtures/blockchain_tests/prague");
+        return loader.LoadTests().OfType<BlockchainTest>();
+    }
+}

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,7 +1,9 @@
 // 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;
 
@@ -11,17 +13,21 @@ namespace Ethereum.Blockchain.Test;
 [Parallelizable(ParallelScope.All)]
 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();
+        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/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;
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System.Collections.Generic;
+using System.Text.Json.Serialization;
+
+namespace Ethereum.Test.Base
+{
+    public class EofTestJson
+    {
+        [JsonPropertyName("_info")]
+        public GeneralStateTestInfoJson? Info { get; set; }
+
+        public Dictionary<string, VectorTestJson> Vectors { get; set; }
+
+    }
+}

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

@@ -1,8 +1,6 @@
 // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
 // SPDX-License-Identifier: LGPL-3.0-only
 
-using System.Text.Json.Serialization;
-
 using Nethermind.Core.Crypto;
 
 namespace Ethereum.Test.Base

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

@@ -20,6 +20,29 @@ public FileTestsSource(string fileName, string? wildcard = null)
             _wildcard = wildcard;
         }
 
+        public IEnumerable<EofTest> LoadEofTests()
+        {
+            try
+            {
+                if (Path.GetFileName(_fileName).StartsWith("."))
+                {
+                    return Enumerable.Empty<EofTest>();
+                }
+
+                if (_wildcard is not null && !_fileName.Contains(_wildcard))
+                {
+                    return Enumerable.Empty<EofTest>();
+                }
+
+                string json = File.ReadAllText(_fileName);
+                return JsonToEthereumTest.ConvertToEofTests(json);
+            }
+            catch (Exception e)
+            {
+                return Enumerable.Repeat(new EofTest { Name = _fileName, LoadFailure = $"Failed to load: {e}" }, 1);
+            }
+        }
+
         public IEnumerable<GeneralStateTest> LoadGeneralStateTests()
         {
             try
@@ -35,7 +58,7 @@ public IEnumerable<GeneralStateTest> LoadGeneralStateTests()
                 }
 
                 string json = File.ReadAllText(_fileName);
-                return JsonToEthereumTest.Convert(json);
+                return JsonToEthereumTest.ConvertStateTest(json);
             }
             catch (Exception e)
             {