feature: Add support for block validation (flashbots_validateBuilderSubmissionV3)

.github/workflows/nethermind-tests.yml

@@ -46,6 +46,7 @@ jobs:
           - Nethermind.EthStats.Test
           - Nethermind.Evm.Test
           - Nethermind.Facade.Test
+          - Nethermind.Flashbots.Test
           - Nethermind.HealthChecks.Test
           - Nethermind.Hive.Test
           - Nethermind.JsonRpc.Test

src/Nethermind/Nethermind.Api/Extensions/PluginConfig.cs

@@ -5,5 +5,5 @@ namespace Nethermind.Api.Extensions;
 
 public class PluginConfig : IPluginConfig
 {
-    public string[] PluginOrder { get; set; } = { "Clique", "Aura", "Ethash", "Optimism", "Shutter", "Taiko", "AuRaMerge", "Merge", "MEV", "HealthChecks", "Hive" };
+    public string[] PluginOrder { get; set; } = { "Clique", "Aura", "Ethash", "Optimism", "Shutter", "Taiko", "AuRaMerge", "Merge", "Flashbots", "MEV", "HealthChecks", "Hive" };
 }

src/Nethermind/Nethermind.Flashbots.Test/FlashbotsModuleTests.Setup.cs

@@ -0,0 +1,82 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System.Threading.Tasks;
+using Nethermind.Core;
+using Nethermind.Crypto;
+using Nethermind.Flashbots.Handlers;
+using Nethermind.Flashbots.Modules.Flashbots;
+using Nethermind.Int256;
+using NUnit.Framework;
+using Nethermind.Merge.Plugin.Test;
+using Nethermind.Specs.Forks;
+using Nethermind.Specs;
+using Nethermind.Consensus.Processing;
+using Nethermind.Core.Specs;
+using Nethermind.Core.Extensions;
+
+namespace Nethermind.Flashbots.Test;
+
+public partial class FlashbotsModuleTests
+{
+    TestKeyAndAddress? TestKeysAndAddress;
+
+    [SetUp]
+    public void SetUp()
+    {
+        TestKeysAndAddress = new TestKeyAndAddress();
+    }
+
+    internal class TestKeyAndAddress
+    {
+        public PrivateKey PrivateKey = new PrivateKey("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291");
+        public Address TestAddr;
+
+        public PrivateKey TestValidatorKey = new PrivateKey("28c3cd61b687fdd03488e167a5d84f50269df2a4c29a2cfb1390903aa775c5d0");
+        public Address TestValidatorAddr;
+
+        public PrivateKey TestBuilderKey = new PrivateKey("0bfbbbc68fefd990e61ba645efb84e0a62e94d5fff02c9b1da8eb45fea32b4e0");
+        public Address TestBuilderAddr;
+
+        public UInt256 TestBalance = UInt256.Parse("2000000000000000000");
+        public byte[] logCode = Bytes.FromHexString("60606040525b7f24ec1d3ff24c2f6ff210738839dbc339cd45a5294d85c79361016243157aae7b60405180905060405180910390a15b600a8060416000396000f360606040526008565b00");
+
+        public UInt256 BaseInitialFee = 1000000000;
+        public TestKeyAndAddress()
+        {
+            TestAddr = PrivateKey.Address;
+            TestValidatorAddr = TestValidatorKey.Address;
+            TestBuilderAddr = TestBuilderKey.Address;
+        }
+    }
+
+    public ReadOnlyTxProcessingEnvFactory CreateReadOnlyTxProcessingEnvFactory(EngineModuleTests.MergeTestBlockchain chain)
+    {
+        ReadOnlyTxProcessingEnvFactory readOnlyTxProcessingEnvFactory = new(
+            chain.WorldStateManager,
+            chain.BlockTree,
+            chain.SpecProvider,
+            chain.LogManager
+        );
+        return readOnlyTxProcessingEnvFactory;
+    }
+
+    protected static async Task<EngineModuleTests.MergeTestBlockchain> CreateBlockChain(
+        IReleaseSpec? releaseSpec = null)
+    => await new EngineModuleTests.MergeTestBlockchain().Build(new TestSingleReleaseSpecProvider(releaseSpec ?? London.Instance));
+
+    private IFlashbotsRpcModule CreateFlashbotsModule(EngineModuleTests.MergeTestBlockchain chain, ReadOnlyTxProcessingEnvFactory readOnlyTxProcessingEnvFactory)
+    {
+        return new FlashbotsRpcModule(
+            new ValidateSubmissionHandler(
+                chain.HeaderValidator,
+                chain.BlockTree,
+                chain.BlockValidator,
+                readOnlyTxProcessingEnvFactory,
+                chain.LogManager,
+                chain.SpecProvider,
+                new FlashbotsConfig()
+            )
+        );
+    }
+}

src/Nethermind/Nethermind.Flashbots.Test/FlashbotsModuleTests.cs

@@ -0,0 +1,116 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Nethermind.Consensus.Processing;
+using Nethermind.Core;
+using Nethermind.Core.Crypto;
+using Nethermind.Core.Extensions;
+using Nethermind.Core.Specs;
+using Nethermind.Core.Test.Builders;
+using Nethermind.Flashbots.Data;
+using Nethermind.Flashbots.Modules.Flashbots;
+using Nethermind.Int256;
+using Nethermind.JsonRpc;
+using Nethermind.JsonRpc.Test;
+using Nethermind.Merge.Plugin.Data;
+using Nethermind.Merge.Plugin.Test;
+using Nethermind.Specs.Forks;
+using Nethermind.State;
+using NUnit.Framework;
+
+namespace Nethermind.Flashbots.Test;
+
+public partial class FlashbotsModuleTests
+{
+    private static readonly DateTime Timestamp = DateTimeOffset.FromUnixTimeSeconds(1000).UtcDateTime;
+    private ITimestamper Timestamper { get; } = new ManualTimestamper(Timestamp);
+
+    [Test]
+    public virtual async Task TestValidateBuilderSubmissionV3()
+    {
+        using EngineModuleTests.MergeTestBlockchain chain = await CreateBlockChain(releaseSpec: Cancun.Instance);
+        ReadOnlyTxProcessingEnvFactory readOnlyTxProcessingEnvFactory = CreateReadOnlyTxProcessingEnvFactory(chain);
+        IFlashbotsRpcModule rpc = CreateFlashbotsModule(chain, readOnlyTxProcessingEnvFactory);
+
+        Block block = CreateBlock(chain);
+
+        GetPayloadV3Result expectedPayload = new(block, UInt256.Zero, new BlobsBundleV1(block));
+
+        BuilderBlockValidationRequest BlockRequest = new(
+            new BidTrace(
+                0, block.Header.ParentHash,
+                block.Header.Hash,
+                TestKeysAndAddress.TestBuilderKey.PublicKey,
+                TestKeysAndAddress.TestValidatorKey.PublicKey,
+                TestKeysAndAddress.TestBuilderAddr,
+                block.Header.GasLimit,
+                block.Header.GasUsed,
+                new UInt256(132912184722469)
+            ),
+            new RExecutionPayloadV3(ExecutionPayloadV3.Create(block)),
+            expectedPayload.BlobsBundle,
+            [],
+            block.Header.GasLimit,
+            new Hash256("0x0000000000000000000000000000000000000000000000000000000000000042")
+        );
+
+        ResultWrapper<FlashbotsResult> result = await rpc.flashbots_validateBuilderSubmissionV3(BlockRequest);
+        result.Should().NotBeNull();
+
+        Assert.That(result.Result.Error, Is.EqualTo("No proposer payment receipt"));
+        Assert.That(result.Data.Status, Is.EqualTo(FlashbotsStatus.Invalid));
+
+        string response = await RpcTest.TestSerializedRequest(rpc, "flashbots_validateBuilderSubmissionV3", BlockRequest);
+        JsonRpcSuccessResponse? jsonResponse = chain.JsonSerializer.Deserialize<JsonRpcSuccessResponse>(response);
+        jsonResponse.Should().NotBeNull();
+    }
+
+    private Block CreateBlock(EngineModuleTests.MergeTestBlockchain chain)
+    {
+        BlockHeader currentHeader = chain.BlockTree.Head.Header;
+        IWorldState State = chain.State;
+        State.CreateAccount(TestKeysAndAddress.TestAddr, TestKeysAndAddress.TestBalance);
+        UInt256 nonce = State.GetNonce(TestKeysAndAddress.TestAddr);
+
+        Withdrawal[] withdrawals = [
+            Build.A.Withdrawal.WithIndex(0).WithValidatorIndex(1).WithAmount(100).WithRecipient(TestKeysAndAddress.TestAddr).TestObject,
+            Build.A.Withdrawal.WithIndex(1).WithValidatorIndex(1).WithAmount(100).WithRecipient(TestKeysAndAddress.TestAddr).TestObject
+        ];
+
+        Hash256 prevRandao = Keccak.Zero;
+
+        Hash256 expectedBlockHash = new("0x479f7c9b7389e9ff3f443b99c3cd4b90f9b7feef5f41d714edb59de6b3e7ac02");
+        string stateRoot = "0xa272b2f949e4a0e411c9b45542bd5d0ef3c311b5f26c4ed6b7a8d4f605a91154";
+
+        return new(
+            new(
+                currentHeader.Hash,
+                Keccak.OfAnEmptySequenceRlp,
+                TestKeysAndAddress.TestAddr,
+                UInt256.Zero,
+                1,
+                chain.BlockTree.Head!.GasLimit,
+                currentHeader.Timestamp + 12,
+                Bytes.FromHexString("0x4e65746865726d696e64") // Nethermind
+            )
+            {
+                BlobGasUsed = 0,
+                ExcessBlobGas = 0,
+                BaseFeePerGas = 0,
+                Bloom = Bloom.Empty,
+                GasUsed = 0,
+                Hash = expectedBlockHash,
+                MixHash = prevRandao,
+                ParentBeaconBlockRoot = Keccak.Zero,
+                ReceiptsRoot = chain.BlockTree.Head!.ReceiptsRoot!,
+                StateRoot = new(stateRoot),
+            },
+            [],
+            Array.Empty<BlockHeader>(),
+            withdrawals
+        );
+    }
+}

src/Nethermind/Nethermind.Flashbots.Test/Nethermind.Flashbots.Test.csproj

@@ -0,0 +1,31 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <Nullable>annotations</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="FluentAssertions" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="NSubstitute" />
+    <PackageReference Include="NUnit" />
+    <PackageReference Include="NUnit.Analyzers">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="NUnit3TestAdapter" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Nethermind.JsonRpc.Test\Nethermind.JsonRpc.Test.csproj" />
+    <ProjectReference Include="..\Nethermind.Consensus\Nethermind.Consensus.csproj" />
+    <ProjectReference Include="..\Nethermind.Core.Test\Nethermind.Core.Test.csproj" />
+    <ProjectReference Include="..\Nethermind.Merge.Plugin.Test\Nethermind.Merge.Plugin.Test.csproj" />
+    <ProjectReference Include="..\Nethermind.Flashbots\Nethermind.Flashbots.csproj" />
+  </ItemGroup>
+
+</Project>

src/Nethermind/Nethermind.Flashbots/Data/BidTrace.cs

@@ -0,0 +1,62 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using Nethermind.Core;
+using Nethermind.Core.Crypto;
+using Nethermind.Int256;
+
+namespace Nethermind.Flashbots.Data;
+
+using System.Text.Json.Serialization;
+
+public class BidTrace
+{
+    [JsonPropertyName("slot")]
+    public ulong Slot { get; set; }
+
+    [JsonPropertyName("parent_hash")]
+    public Hash256 ParentHash { get; set; }
+
+    [JsonPropertyName("block_hash")]
+    public Hash256 BlockHash { get; set; }
+
+    [JsonPropertyName("builder_public_key")]
+    public PublicKey BuilderPublicKey { get; set; }
+
+    [JsonPropertyName("proposer_public_key")]
+    public PublicKey ProposerPublicKey { get; set; }
+
+    [JsonPropertyName("proposer_fee_recipient")]
+    public Address ProposerFeeRecipient { get; set; }
+
+    [JsonPropertyName("gas_limit")]
+    public long GasLimit { get; set; }
+
+    [JsonPropertyName("gas_used")]
+    public long GasUsed { get; set; }
+
+    [JsonPropertyName("value")]
+    public UInt256 Value { get; set; }
+
+    public BidTrace(
+        ulong slot,
+        Hash256 parentHash,
+        Hash256 blockHash,
+        PublicKey builderPublicKey,
+        PublicKey proposerPublicKey,
+        Address proposerFeeRecipient,
+        long gasLimit,
+        long gasUsed,
+        UInt256 value)
+    {
+        Slot = slot;
+        ParentHash = parentHash;
+        BlockHash = blockHash;
+        BuilderPublicKey = builderPublicKey;
+        ProposerPublicKey = proposerPublicKey;
+        ProposerFeeRecipient = proposerFeeRecipient;
+        GasLimit = gasLimit;
+        GasUsed = gasUsed;
+        Value = value;
+    }
+}

src/Nethermind/Nethermind.Flashbots/Data/BlockValidationResult.cs

@@ -0,0 +1,47 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System.Text.Json.Serialization;
+using Nethermind.JsonRpc;
+
+namespace Nethermind.Flashbots.Data;
+
+/// <summary>
+/// Represents the result of a block validation.
+/// </summary>
+public class FlashbotsResult
+{
+
+    public static ResultWrapper<FlashbotsResult> Invalid(string error)
+    {
+        return ResultWrapper<FlashbotsResult>.Fail(error, new FlashbotsResult
+        {
+            Status = FlashbotsStatus.Invalid,
+            ValidationError = error
+        });
+    }
+
+    public static ResultWrapper<FlashbotsResult> Valid()
+    {
+        return ResultWrapper<FlashbotsResult>.Success(new FlashbotsResult
+        {
+            Status = FlashbotsStatus.Valid
+        });
+    }
+
+    public static ResultWrapper<FlashbotsResult> Error(string error)
+    {
+        return ResultWrapper<FlashbotsResult>.Fail(error);
+    }
+
+    /// <summary>
+    /// The status of the validation of the builder submissions
+    /// </summary>
+    public string Status { get; set; } = FlashbotsStatus.Invalid;
+
+    /// <summary>
+    /// Message providing additional details on the validation error if the payload is classified as <see cref="ValidationStatus.Invalid"/>.
+    /// </summary>
+    [JsonIgnore(Condition = JsonIgnoreCondition.Never)]
+    public string? ValidationError { get; set; }
+}

src/Nethermind/Nethermind.Flashbots/Data/BlockValidationStatus.cs

@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+namespace Nethermind.Flashbots.Data;
+
+public static class FlashbotsStatus
+{
+    /// <summary>
+    /// The submissions are invalid.
+    /// </summary>
+    public const string Invalid = "Invalid";
+
+    /// <summary>
+    /// The submissions are valid.
+    /// </summary>
+    public const string Valid = "Valid";
+}