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/Ethereum.Blockchain.Pyspec.Test/PragueStateTests.cs

@@ -0,0 +1,28 @@
+// 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 PragueStateTests : GeneralStateTestBase
+{
+    [TestCaseSource(nameof(LoadTests))]
+    public void Test(GeneralStateTest test) => RunTest(test).Pass.Should().BeTrue();
+
+    private static IEnumerable<GeneralStateTest> LoadTests()
+    {
+        TestsSourceLoader loader = new(new LoadPyspecTestsStrategy()
+        {
+            ArchiveName = "fixtures_eip7692.tar.gz",
+            ArchiveVersion = "[email protected]"
+        }, $"fixtures/state_tests/prague");
+        return loader.LoadTests().Cast<GeneralStateTest>();
+    }
+}

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

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
 using System.Collections.Generic;
+using System.Linq;
 using Ethereum.Test.Base;
 using NUnit.Framework;
 
@@ -13,15 +14,19 @@ public class EOFTests : GeneralStateTestBase
 {
     // Uncomment when EOF tests are merged
 
-    // [TestCaseSource(nameof(LoadTests))]
-    // public void Test(GeneralStateTest test)
-    // {
-    //     Assert.True(RunTest(test).Pass);
-    // }
+    [TestCaseSource(nameof(LoadTests))]
+    public void Test(GeneralStateTest test)
+    {
+        Assert.True(RunTest(test).Pass);
+    }
 
     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/LoadEofTestsStrategy.cs

@@ -0,0 +1,72 @@
+// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Ethereum.Test.Base.Interfaces;
+
+namespace Ethereum.Test.Base
+{
+    public class LoadEofTestsStrategy : ITestLoadStrategy
+    {
+        public IEnumerable<IEthereumTest> Load(string testsDirectoryName, string wildcard = null)
+        {
+            IEnumerable<string> testDirs;
+            if (!Path.IsPathRooted(testsDirectoryName))
+            {
+                string testsDirectory = GetGeneralStateTestsDirectory();
+
+
+                testDirs = Directory.EnumerateDirectories(testsDirectory, testsDirectoryName, new EnumerationOptions { RecurseSubdirectories = true });
+            }
+            else
+            {
+                testDirs = new[] { testsDirectoryName };
+            }
+
+            List<GeneralStateTest> testJsons = new();
+            foreach (string testDir in testDirs)
+            {
+                testJsons.AddRange(LoadTestsFromDirectory(testDir, wildcard));
+            }
+
+            return testJsons;
+        }
+
+        private string GetGeneralStateTestsDirectory()
+        {
+            char pathSeparator = Path.AltDirectorySeparatorChar;
+            string currentDirectory = AppDomain.CurrentDomain.BaseDirectory;
+
+            return currentDirectory.Remove(currentDirectory.LastIndexOf("src")) + $"src{pathSeparator}tests{pathSeparator}EIPTests{pathSeparator}StateTests{pathSeparator}stEOF";
+        }
+
+        private IEnumerable<GeneralStateTest> LoadTestsFromDirectory(string testDir, string wildcard)
+        {
+            List<GeneralStateTest> testsByName = new();
+            IEnumerable<string> testFiles = Directory.EnumerateFiles(testDir);
+
+            foreach (string testFile in testFiles)
+            {
+                FileTestsSource fileTestsSource = new(testFile, wildcard);
+                try
+                {
+                    var tests = fileTestsSource.LoadGeneralStateTests();
+                    foreach (GeneralStateTest blockchainTest in tests)
+                    {
+                        blockchainTest.Category = testDir;
+                    }
+
+                    testsByName.AddRange(tests);
+                }
+                catch (Exception e)
+                {
+                    testsByName.Add(new GeneralStateTest { Name = testFile, LoadFailure = $"Failed to load: {e}" });
+                }
+            }
+
+            return testsByName;
+        }
+    }
+}

src/Nethermind/Nethermind.Consensus/Messages/TxErrorMessages.cs

@@ -78,4 +78,16 @@ public static string InvalidTxChainId(ulong expected, ulong? actual) =>
 
     public const string InvalidBlobData
         = "InvalidTxBlobData: Number of blobs, hashes, commitments and proofs must match.";
+
+    public const string InvalidCreateTxData
+        = "InvalidCreateTxData: Legacy createTx cannot create Eof code";
+
+    public const string TooManyEofInitcodes
+        = $"TooManyEofInitcodes: Eof initcodes count exceeded limit";
+
+    public const string EmptyEofInitcodesField
+        = $"EmptyEofInitcodesField: Eof initcodes count must be greater than 0";
+
+    public const string EofContractSizeInvalid
+        = "EofContractSizeInvalid: Eof initcode size is invalid (either 0 or too big)";
 }

src/Nethermind/Nethermind.Consensus/Validators/TxValidator.cs

@@ -9,6 +9,7 @@
 using Nethermind.Core.Specs;
 using Nethermind.Crypto;
 using Nethermind.Evm;
+using Nethermind.Evm.EOF;
 using Nethermind.Int256;
 using Nethermind.TxPool;
 

src/Nethermind/Nethermind.Core/Extensions/Bytes.cs

@@ -29,6 +29,7 @@ public static unsafe partial class Bytes
         public static readonly BytesComparer Comparer = new();
         public static readonly ReadOnlyMemory<byte> ZeroByte = new byte[] { 0 };
         public static readonly ReadOnlyMemory<byte> OneByte = new byte[] { 1 };
+        public static readonly ReadOnlyMemory<byte> TwoByte = new byte[] { 2 };
 
         private class BytesEqualityComparer : EqualityComparer<byte[]>
         {
@@ -364,6 +365,62 @@ public static BigInteger ToUnsignedBigInteger(this ReadOnlySpan<byte> bytes)
         {
             return new(bytes, true, true);
         }
+        public static short ReadEthInt16(this Span<byte> bytes)
+        {
+            return ReadEthInt16((ReadOnlySpan<byte>)bytes);
+        }
+
+        public static short ReadEthInt16(this ReadOnlySpan<byte> bytes)
+        {
+            if (bytes.Length > 2)
+            {
+                bytes = bytes.Slice(bytes.Length - 2, 2);
+            }
+
+            return bytes.Length switch
+            {
+                2 => BinaryPrimitives.ReadInt16BigEndian(bytes),
+                1 => bytes[0],
+                _ => 0
+            };
+        }
+
+        public static ushort ReadEthUInt16(this Span<byte> bytes)
+        {
+            return ReadEthUInt16((ReadOnlySpan<byte>)bytes);
+        }
+
+        public static ushort ReadEthUInt16(this ReadOnlySpan<byte> bytes)
+        {
+            if (bytes.Length > 2)
+            {
+                bytes = bytes.Slice(bytes.Length - 2, 2);
+            }
+
+            return bytes.Length switch
+            {
+                2 => BinaryPrimitives.ReadUInt16BigEndian(bytes),
+                1 => bytes[0],
+                _ => 0
+            };
+        }
+
+        public static ushort ReadEthUInt16LittleEndian(this Span<byte> bytes)
+        {
+            if (bytes.Length > 2)
+            {
+                bytes = bytes.Slice(bytes.Length - 2, 2);
+            }
+
+            if (bytes.Length == 2)
+            {
+                return BinaryPrimitives.ReadUInt16LittleEndian(bytes);
+            }
+
+            Span<byte> twoBytes = stackalloc byte[2];
+            bytes.CopyTo(twoBytes[(2 - bytes.Length)..]);
+            return BinaryPrimitives.ReadUInt16LittleEndian(twoBytes);
+        }
 
         public static uint ReadEthUInt32(this Span<byte> bytes)
         {

src/Nethermind/Nethermind.Core/Extensions/Int16Extensions.cs

@@ -0,0 +1,32 @@
+// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using System.Buffers.Binary;
+
+namespace Nethermind.Core.Extensions;
+
+public static class short16Extensions
+{
+    public static byte[] ToByteArray(this short value)
+    {
+        byte[] bytes = new byte[sizeof(short)];
+        BinaryPrimitives.WriteInt16BigEndian(bytes, value);
+        return bytes;
+    }
+
+    public static byte[] ToBigEndianByteArray(this ushort value)
+    {
+        byte[] bytes = BitConverter.GetBytes(value);
+        if (BitConverter.IsLittleEndian)
+        {
+            Array.Reverse(bytes);
+        }
+
+        return bytes;
+    }
+
+    public static byte[] ToBigEndianByteArray(this short value)
+        => ToBigEndianByteArray((ushort)value);
+
+}

src/Nethermind/Nethermind.Core/Extensions/Int64Extensions.cs

@@ -117,7 +117,7 @@ public static byte[] ToBigEndianByteArrayWithoutLeadingZeros(this long value)
         }
     }
 
-    public static byte[] ToBigEndianByteArray(this long value)
+    public static byte[] ToBigEndianByteArray(this ulong value)
     {
         byte[] bytes = BitConverter.GetBytes(value);
         if (BitConverter.IsLittleEndian)
@@ -127,6 +127,10 @@ public static byte[] ToBigEndianByteArray(this long value)
 
         return bytes;
     }
+
+    public static byte[] ToBigEndianByteArray(this long value)
+        => ToBigEndianByteArray((ulong)value);
+
     public static void WriteBigEndian(this long value, Span<byte> output)
     {
         BinaryPrimitives.WriteInt64BigEndian(output, value);

src/Nethermind/Nethermind.Core/Extensions/IntExtensions.cs

@@ -36,7 +36,7 @@ public static byte[] ToByteArray(this int value)
         return bytes;
     }
 
-    public static byte[] ToBigEndianByteArray(this int value)
+    public static byte[] ToBigEndianByteArray(this uint value)
     {
         byte[] bytes = BitConverter.GetBytes(value);
         if (BitConverter.IsLittleEndian)
@@ -46,4 +46,7 @@ public static byte[] ToBigEndianByteArray(this int value)
 
         return bytes;
     }
+
+    public static byte[] ToBigEndianByteArray(this int value)
+        => ToBigEndianByteArray((uint)value);
 }

src/Nethermind/Nethermind.Core/Specs/IReleaseSpec.cs

@@ -284,6 +284,11 @@ public interface IReleaseSpec : IEip1559Spec, IReceiptSpec
         /// </summary>
         bool IsEip6780Enabled { get; }
 
+        /// <summary>
+        /// Eof execution env in EVM
+        /// </summary>
+        bool IsEofEnabled { get; }
+
         /// <summary>
         /// Secp256r1 precompile
         /// </summary>

src/Nethermind/Nethermind.Evm.Benchmark/EvmBenchmarks.cs

@@ -55,7 +55,7 @@ public void GlobalSetup()
                 codeInfo: new CodeInfo(ByteCode),
                 value: 0,
                 transferValue: 0,
-                txExecutionContext: new TxExecutionContext(_header, Address.Zero, 0, null),
+                txExecutionContext: new TxExecutionContext(_header, Address.Zero, 0, []),
                 inputData: default
             );
 

src/Nethermind/Nethermind.Evm.Benchmark/MultipleUnsignedOperations.cs

@@ -87,7 +87,7 @@ public void GlobalSetup()
             codeInfo: new CodeInfo(_bytecode.Concat(_bytecode).Concat(_bytecode).Concat(_bytecode).ToArray()),
             value: 0,
             transferValue: 0,
-            txExecutionContext: new TxExecutionContext(_header, Address.Zero, 0, null),
+            txExecutionContext: new TxExecutionContext(_header, Address.Zero, 0, []),
             inputData: default
         );
 

src/Nethermind/Nethermind.Evm.Benchmark/StaticCallBenchmarks.cs

@@ -98,7 +98,7 @@ public void GlobalSetup()
                 codeInfo: new CodeInfo(Bytecode),
                 value: 0,
                 transferValue: 0,
-                txExecutionContext: new TxExecutionContext(_header, Address.Zero, 0, null),
+                txExecutionContext: new TxExecutionContext(_header, Address.Zero, 0, []),
                 inputData: default
             );