Add EngineRequestGenerator tool

Directory.Packages.props

@@ -13,6 +13,7 @@
     <PackageVersion Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.15.0" />
     <PackageVersion Include="BouncyCastle.Cryptography" Version="2.6.1" />
     <PackageVersion Include="Ckzg.Bindings" Version="2.1.1.1401" />
+    <PackageVersion Include="CommandLineParser" Version="2.9.1" />
     <PackageVersion Include="CommunityToolkit.HighPerformance" Version="8.4.0" />
     <PackageVersion Include="ConcurrentHashSet" Version="1.3.0" />
     <PackageVersion Include="Crc32.NET" Version="1.2.0" />

src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs

@@ -162,6 +162,7 @@ ISealer Sealer
     public class Configuration
     {
         public bool SuggestGenesisOnStart = true;
+        public bool KeepStateEmptyAtInit = false;
         public bool AddBlockOnStart = true;
         public UInt256 AccountInitialValue = InitialValue;
         public long SlotTime = 1;
@@ -187,45 +188,49 @@ protected virtual async Task<TestBlockchain> Build(Action<ContainerBuilder>? con
         IWorldState state = _fromContainer.WorldStateManager.GlobalWorldState;
 
         ISpecProvider specProvider = SpecProvider;
-        // Eip4788 precompile state account
-        if (specProvider?.GenesisSpec?.IsBeaconBlockRootAvailable ?? false)
-        {
-            state.CreateAccount(SpecProvider.GenesisSpec.Eip4788ContractAddress!, 1);
-        }
+        Configuration testConfiguration = _fromContainer.Configuration;
 
-        // Eip2935
-        if (specProvider?.GenesisSpec?.IsBlockHashInStateAvailable ?? false)
+        if (!testConfiguration.KeepStateEmptyAtInit)
         {
-            state.CreateAccount(SpecProvider.GenesisSpec.Eip2935ContractAddress, 1);
-        }
+            // Eip4788 precompile state account
+            if (specProvider?.GenesisSpec?.IsBeaconBlockRootAvailable ?? false)
+            {
+                state.CreateAccount(SpecProvider.GenesisSpec.Eip4788ContractAddress!, 1);
+            }
 
-        Configuration testConfiguration = _fromContainer.Configuration;
-        state.CreateAccount(TestItem.AddressA, testConfiguration.AccountInitialValue);
-        state.CreateAccount(TestItem.AddressB, testConfiguration.AccountInitialValue);
-        state.CreateAccount(TestItem.AddressC, testConfiguration.AccountInitialValue);
+            // Eip2935
+            if (specProvider?.GenesisSpec?.IsBlockHashInStateAvailable ?? false)
+            {
+                state.CreateAccount(SpecProvider.GenesisSpec.Eip2935ContractAddress, 1);
+            }
 
-        InitialStateMutator?.Invoke(state);
+            state.CreateAccount(TestItem.AddressA, testConfiguration.AccountInitialValue);
+            state.CreateAccount(TestItem.AddressB, testConfiguration.AccountInitialValue);
+            state.CreateAccount(TestItem.AddressC, testConfiguration.AccountInitialValue);
 
-        byte[] code = Bytes.FromHexString("0xabcd");
-        state.InsertCode(TestItem.AddressA, code, SpecProvider.GenesisSpec);
-        state.Set(new StorageCell(TestItem.AddressA, UInt256.One), Bytes.FromHexString("0xabcdef"));
+            InitialStateMutator?.Invoke(state);
 
-        IReleaseSpec? finalSpec = specProvider?.GetFinalSpec();
+            byte[] code = Bytes.FromHexString("0xabcd");
+            state.InsertCode(TestItem.AddressA, code, SpecProvider.GenesisSpec);
+            state.Set(new StorageCell(TestItem.AddressA, UInt256.One), Bytes.FromHexString("0xabcdef"));
 
-        if (finalSpec?.WithdrawalsEnabled is true)
-        {
-            state.CreateAccount(Eip7002Constants.WithdrawalRequestPredeployAddress, 0, Eip7002TestConstants.Nonce);
-            state.InsertCode(Eip7002Constants.WithdrawalRequestPredeployAddress, Eip7002TestConstants.CodeHash, Eip7002TestConstants.Code, SpecProvider.GenesisSpec);
-        }
+            IReleaseSpec? finalSpec = specProvider?.GetFinalSpec();
 
-        if (finalSpec?.ConsolidationRequestsEnabled is true)
-        {
-            state.CreateAccount(Eip7251Constants.ConsolidationRequestPredeployAddress, 0, Eip7251TestConstants.Nonce);
-            state.InsertCode(Eip7251Constants.ConsolidationRequestPredeployAddress, Eip7251TestConstants.CodeHash, Eip7251TestConstants.Code, SpecProvider.GenesisSpec);
-        }
+            if (finalSpec?.WithdrawalsEnabled is true)
+            {
+                state.CreateAccount(Eip7002Constants.WithdrawalRequestPredeployAddress, 0, Eip7002TestConstants.Nonce);
+                state.InsertCode(Eip7002Constants.WithdrawalRequestPredeployAddress, Eip7002TestConstants.CodeHash, Eip7002TestConstants.Code, SpecProvider.GenesisSpec);
+            }
 
-        state.Commit(SpecProvider.GenesisSpec);
-        state.CommitTree(0);
+            if (finalSpec?.ConsolidationRequestsEnabled is true)
+            {
+                state.CreateAccount(Eip7251Constants.ConsolidationRequestPredeployAddress, 0, Eip7251TestConstants.Nonce);
+                state.InsertCode(Eip7251Constants.ConsolidationRequestPredeployAddress, Eip7251TestConstants.CodeHash, Eip7251TestConstants.Code, SpecProvider.GenesisSpec);
+            }
+
+            state.Commit(SpecProvider.GenesisSpec);
+            state.CommitTree(0);
+        }
 
         BlockProcessor = CreateBlockProcessor(WorldStateManager.GlobalWorldState);
 

tools/EngineRequestsGenerator/BlockGasVariants.cs

@@ -0,0 +1,30 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+namespace EngineRequestsGenerator;
+
+public static class BlockGasVariants
+{
+    public static long[] Variants =
+    [
+        30_000_000,
+        40_000_000,
+        50_000_000,
+        60_000_000,
+        70_000_000,
+        80_000_000,
+        90_000_000,
+        100_000_000,
+        110_000_000,
+        120_000_000,
+        130_000_000,
+        140_000_000,
+        150_000_000,
+        175_000_000,
+        200_000_000,
+        300_000_000,
+        400_000_000,
+        500_000_000,
+        1_000_000_000
+    ];
+}

tools/EngineRequestsGenerator/ContractFactory.cs

@@ -0,0 +1,102 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using Nethermind.Core.Extensions;
+using Nethermind.Evm;
+
+namespace EngineRequestsGenerator;
+
+public static class ContractFactory
+{
+    public static List<byte> GenerateCodeToDeployContract(List<byte> codeToDeploy)
+    {
+        List<byte> initCode = GenerateInitCode(codeToDeploy);
+        List<byte> byteCode = new();
+
+        for (long i = 0; i < initCode.Count; i += 32)
+        {
+            List<byte> currentWord = i == 0
+                ? initCode.Slice(0, initCode.Count % 32)
+                : initCode.Slice((int)i - 32 + initCode.Count % 32, 32);
+            byteCode.Add((byte)(Instruction.PUSH1 + (byte)currentWord.Count - 1));
+            byteCode.AddRange(currentWord);
+
+            // push memory offset - i
+            byte[] memoryOffset = i.ToBigEndianByteArrayWithoutLeadingZeros();
+            if (memoryOffset is [0])
+            {
+                byteCode.Add((byte)Instruction.PUSH0);
+            }
+            else
+            {
+                byteCode.Add((byte)(Instruction.PUSH1 + (byte)memoryOffset.Length - 1));
+                byteCode.AddRange(memoryOffset);
+            }
+
+            // save in memory
+            byteCode.Add((byte)Instruction.MSTORE);
+        }
+
+        // push size of init code to read from memory
+        byte[] sizeOfInitCode = initCode.Count.ToByteArray().WithoutLeadingZeros().ToArray();
+        byteCode.Add((byte)(Instruction.PUSH1 + (byte)sizeOfInitCode.Length - 1));
+        byteCode.AddRange(sizeOfInitCode);
+
+        // offset in memory
+        byteCode.Add((byte)(Instruction.PUSH1));
+        byteCode.AddRange(new[] { (byte)(32 - (initCode.Count % 32)) });
+
+        // 0 wei to send
+        byteCode.Add((byte)Instruction.PUSH0);
+
+        byteCode.Add((byte)Instruction.CREATE);
+
+        Console.WriteLine($"size of prepared code: {byteCode.Count}");
+
+        return byteCode;
+    }
+
+    private static List<byte> GenerateInitCode(List<byte> codeToDeploy)
+    {
+        List<byte> initCode = new();
+
+        for (long i = 0; i < codeToDeploy.Count; i += 32)
+        {
+            List<byte> currentWord = i == 0
+                ? codeToDeploy.Slice(0, codeToDeploy.Count % 32)
+                : codeToDeploy.Slice((int)i - 32 + codeToDeploy.Count % 32, 32);
+
+            initCode.Add((byte)(Instruction.PUSH1 + (byte)currentWord.Count - 1));
+            initCode.AddRange(currentWord);
+
+            // push memory offset - i
+            byte[] memoryOffset = i.ToBigEndianByteArrayWithoutLeadingZeros();
+            if (memoryOffset is [0])
+            {
+                initCode.Add((byte)Instruction.PUSH0);
+            }
+            else
+            {
+                initCode.Add((byte)(Instruction.PUSH1 + (byte)memoryOffset.Length - 1));
+                initCode.AddRange(memoryOffset);
+            }
+
+            // save in memory
+            initCode.Add((byte)Instruction.MSTORE);
+        }
+
+        // push size of memory read
+        byte[] sizeOfCodeToDeploy = codeToDeploy.Count.ToByteArray().WithoutLeadingZeros().ToArray();
+        initCode.Add((byte)(Instruction.PUSH1 + (byte)sizeOfCodeToDeploy.Length - 1));
+        initCode.AddRange(sizeOfCodeToDeploy);
+
+        // push memory offset
+        initCode.Add((byte)(Instruction.PUSH1));
+        initCode.AddRange(new[] { (byte)(32 - (codeToDeploy.Count % 32)) });
+
+        // add return opcode
+        initCode.Add((byte)(Instruction.RETURN));
+
+        return initCode;
+    }
+}

tools/EngineRequestsGenerator/EngineRequestsGenerator.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Nethermind\Nethermind.Core\Nethermind.Core.csproj" />
+    <ProjectReference Include="..\..\src\Nethermind\Nethermind.Merge.Plugin\Nethermind.Merge.Plugin.csproj" />
+    <ProjectReference Include="..\..\src\Nethermind\Nethermind.Merge.Plugin.Test\Nethermind.Merge.Plugin.Test.csproj" />
+    <PackageReference Include="CommandLineParser" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="benchmarks_chainspec.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <StartupObject>EngineRequestsGenerator.Program</StartupObject>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+</Project>

tools/EngineRequestsGenerator/MetadataGenerator.cs

@@ -0,0 +1,61 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System.Reflection;
+using Nethermind.Serialization.Json;
+using Newtonsoft.Json;
+
+namespace EngineRequestsGenerator;
+
+public class MetadataGenerator
+{
+    private readonly string _outputPath;
+
+    public MetadataGenerator(string outputPath)
+    {
+        _outputPath = outputPath;
+    }
+
+    public async Task GenerateAll()
+    {
+        TestCase[] testCases = (TestCase[])Enum.GetValues(typeof(TestCase));
+        var metadatas = new Metadata[testCases.Length];
+        for (int i = 0; i < testCases.Length; ++i)
+        {
+            metadatas[i] = GetOne(testCases[i]);
+        }
+        var str = JsonConvert.SerializeObject(metadatas);
+
+        await File.WriteAllTextAsync($"{_outputPath}/metadata.json", str);
+
+    }
+
+    private Metadata GetOne(TestCase testCase)
+    {
+        TestCaseMetadataAttribute metadataAttribute = GetTestCaseMetadata(testCase);
+        var metadata = new Metadata(Enum.GetName(typeof(TestCase),testCase)!, metadataAttribute.Title, metadataAttribute.Description);
+        return metadata;
+    }
+
+    public class Metadata(string name, string title, string description)
+    {
+        public string Name { get; set; } = name;
+
+        public string Title { get; set; } = title;
+
+        public string Description { get; set; } = description;
+
+        public long[] GasUsed = BlockGasVariants.Variants;
+    }
+
+    static TestCaseMetadataAttribute GetTestCaseMetadata(TestCase testCase)
+    {
+        FieldInfo? fieldInfo = testCase.GetType().GetField(testCase.ToString());
+        TestCaseMetadataAttribute[]? attributes = (TestCaseMetadataAttribute[])fieldInfo!.GetCustomAttributes(typeof(TestCaseMetadataAttribute), false);
+
+        if (attributes == null || attributes.Length != 1)
+            throw new ArgumentException("Incorrect amount of attributes found");
+
+        return attributes[0];
+    }
+}

tools/EngineRequestsGenerator/Program.cs

@@ -0,0 +1,48 @@
+using CommandLine;
+
+namespace EngineRequestsGenerator;
+
+
+public static class Program
+{
+    public class Options
+    {
+        [Option('c', "chainspecpath", Required = false, HelpText = "Path to chainspec used to generate tests")]
+        public string? ChainspecPath { get; set; }
+
+        [Option('t', "testcase", Required = false, HelpText = "Title of the test case")]
+        public string? TestCaseName { get; set; }
+
+        [Option('o', "outputPath", Required = false, HelpText = "Output folder path")]
+        public string? OutputPath { get; set; }
+
+        [Option('m', "generateMetadataOnly", Required = false, HelpText = "Generating only metadata for test cases")]
+        public bool GenerateMetadata { get; set; }
+    }
+
+    static async Task Main(string[] args)
+    {
+        ParserResult<Options> result = Parser.Default.ParseArguments<Options>(args);
+        if (result is Parsed<Options> options)
+            await Run(options.Value);
+    }
+
+    private static async Task Run(Options options)
+    {
+        if (!options.GenerateMetadata)
+        {
+            var foundTestCase = Enum.TryParse(options.TestCaseName, out TestCase testCase);
+            if (!foundTestCase)
+                throw new ArgumentException($"Test case {options.TestCaseName} not found");
+
+            var testCaseGenerator = new TestCaseGenerator(options.ChainspecPath!, testCase, options.OutputPath!);
+            await testCaseGenerator.Generate();
+        }
+
+        if (options.GenerateMetadata)
+        {
+            MetadataGenerator metadataGenerator = new(options.OutputPath!);
+            await metadataGenerator.GenerateAll();
+        }
+    }
+}

tools/EngineRequestsGenerator/Properties/launchSettings.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "profiles": {
+    "EngineRequestsGenerator": {
+      "commandName": "Project",
+      "commandLineArgs": "-c benchmarks_chainspec.json -t Modexp215GasExpHeavy -o testcases"
+    },
+    "MetadataGenerator": {
+      "commandName": "Project",
+      "commandLineArgs": "-m true -o testcases"
+    }
+  }
+}