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", "AuRaMerge", "Merge", "MEV", "HealthChecks", "Hive" };
+    public string[] PluginOrder { get; set; } = { "Clique", "Aura", "Ethash", "Optimism", "Shutter", "AuRaMerge", "Merge", "Flashbots", "MEV", "HealthChecks", "Hive" };
 }

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

@@ -0,0 +1,171 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System.Threading.Tasks;
+using Nethermind.Blockchain.BeaconBlockRoot;
+using Nethermind.Blockchain.Blocks;
+using Nethermind.Blockchain.Synchronization;
+using Nethermind.Consensus;
+using Nethermind.Consensus.Processing;
+using Nethermind.Consensus.Rewards;
+using Nethermind.Consensus.Validators;
+using Nethermind.Consensus.Withdrawals;
+using Nethermind.Core;
+using Nethermind.Core.Extensions;
+using Nethermind.Core.Specs;
+using Nethermind.Core.Test.Blockchain;
+using Nethermind.Crypto;
+using Nethermind.Db;
+using Nethermind.Flashbots;
+using Nethermind.Flashbots.Handlers;
+using Nethermind.Flashbots.Modules.Flashbots;
+using Nethermind.Int256;
+using Nethermind.Logging;
+using Nethermind.Merge.Plugin;
+using Nethermind.Specs;
+using Nethermind.Specs.ChainSpecStyle;
+using Nethermind.Specs.Forks;
+using NUnit.Framework;
+
+namespace Nethermind.Flasbots.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 TestKeyAndAddress()
+        {
+            TestAddr = privateKey.Address;
+            TestValidatorAddr = TestValidatorKey.Address;
+            TestBuilderAddr = TestBuilderKey.Address;
+        }
+    }
+
+    protected virtual MergeTestBlockChain CreateBaseBlockChain(
+        IFlashbotsConfig flashbotsConfig,
+        ILogManager? logManager = null)
+    {
+        return new MergeTestBlockChain(flashbotsConfig, logManager);
+    }
+
+    protected async Task<MergeTestBlockChain> CreateBlockChain(
+        IReleaseSpec? releaseSpec = null,
+        IFlashbotsConfig? flashbotsConfig = null,
+        ILogManager? logManager = null)
+    => await CreateBaseBlockChain(flashbotsConfig ?? new FlashbotsConfig(), logManager).Build(new TestSingleReleaseSpecProvider(releaseSpec ?? London.Instance));
+
+    private IFlashbotsRpcModule CreateFlashbotsModule(MergeTestBlockChain chain, ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv)
+    {
+        return new FlashbotsRpcModule(
+            new ValidateSubmissionHandler(
+                chain.HeaderValidator,
+                chain.BlockValidator,
+                readOnlyTxProcessingEnv,
+                chain.FlashbotsConfig
+            )
+        );
+    }
+
+    public class MergeTestBlockChain : TestBlockchain
+    {
+        public IFlashbotsConfig FlashbotsConfig;
+
+        public IMergeConfig MergeConfig;
+
+        public IWithdrawalProcessor? WithdrawalProcessor { get; set; }
+
+        public ReadOnlyTxProcessingEnv ReadOnlyTxProcessingEnv { get; set; }
+
+        public MergeTestBlockChain(IFlashbotsConfig flashbotsConfig, ILogManager? logManager = null)
+        {
+            FlashbotsConfig = flashbotsConfig;
+            MergeConfig = new MergeConfig() { TerminalTotalDifficulty = "0" };
+            LogManager = logManager ?? LogManager;
+        }
+
+        public sealed override ILogManager LogManager { get; set; } = LimboLogs.Instance;
+
+        public ReadOnlyTxProcessingEnv CreateReadOnlyTxProcessingEnv()
+        {
+            ReadOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(
+                WorldStateManager,
+                BlockTree,
+                SpecProvider,
+                LogManager
+            );
+            return ReadOnlyTxProcessingEnv;
+        }
+
+        protected override IBlockProcessor CreateBlockProcessor()
+        {
+            BlockValidator = CreateBlockValidator();
+            WithdrawalProcessor = new WithdrawalProcessor(State, LogManager);
+            IBlockProcessor prcessor = new BlockProcessor(
+                SpecProvider,
+                BlockValidator,
+                NoBlockRewards.Instance,
+                new BlockProcessor.BlockValidationTransactionsExecutor(TxProcessor, State),
+                State,
+                ReceiptStorage,
+                TxProcessor,
+                new BeaconBlockRootHandler(TxProcessor),
+                new BlockhashStore(SpecProvider, State),
+                LogManager,
+                WithdrawalProcessor
+            );
+
+            return prcessor;
+        }
+
+        protected IBlockValidator CreateBlockValidator()
+        {
+            PoSSwitcher = new PoSSwitcher(MergeConfig, SyncConfig.Default, new MemDb(), BlockTree, SpecProvider, new ChainSpec() { Genesis = Core.Test.Builders.Build.A.Block.WithDifficulty(0).TestObject }, LogManager);
+            ISealValidator SealValidator = new MergeSealValidator(PoSSwitcher, Always.Valid);
+            HeaderValidator = new MergeHeaderValidator(
+                PoSSwitcher,
+                new HeaderValidator(BlockTree, SealValidator, SpecProvider, LogManager),
+                BlockTree,
+                SpecProvider,
+                SealValidator,
+                LogManager
+            );
+
+            return new BlockValidator(
+                new TxValidator(SpecProvider.ChainId),
+                HeaderValidator,
+                Always.Valid,
+                SpecProvider,
+                LogManager
+            );
+        }
+
+        protected override async Task<TestBlockchain> Build(ISpecProvider? specProvider = null, UInt256? initialValues = null, bool addBlockOnStart = true)
+        {
+            TestBlockchain chain = await base.Build(specProvider, initialValues);
+            return chain;
+        }
+
+        public async Task<MergeTestBlockChain> Build(ISpecProvider? specProvider = null) =>
+            (MergeTestBlockChain)await Build(specProvider, null);
+
+    }
+}

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

@@ -0,0 +1,32 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System.Threading.Tasks;
+using Nethermind.Consensus.Processing;
+using Nethermind.Core;
+using Nethermind.Core.Extensions;
+using Nethermind.Crypto;
+using Nethermind.Flashbots.Modules.Flashbots;
+using Nethermind.Int256;
+using Nethermind.State;
+
+namespace Nethermind.Flasbots.Test;
+
+public partial class FlashbotsModuleTests
+{
+
+    public async Task TestValidateBuilderSubmissionV3()
+    {
+        using MergeTestBlockChain chain = await CreateBlockChain();
+        ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv = chain.CreateReadOnlyTxProcessingEnv();
+        IFlashbotsRpcModule rpc = CreateFlashbotsModule(chain, readOnlyTxProcessingEnv);
+        BlockHeader currentHeader = chain.BlockTree.Head.Header;
+        IWorldState State = chain.State;
+
+        UInt256 nonce = State.GetNonce(TestKeysAndAddress.TestAddr);
+
+        Transaction tx1 = new Transaction(
+
+        );
+    }
+}

src/Nethermind/Nethermind.Flashbots.Test/Nethermind.Flasbots.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.Test\Nethermind.Merge.Test.csproj" />
+    <ProjectReference Include="..\Nethermind.Flashbots\Nethermind.Flashbots.csproj" />
+  </ItemGroup>
+
+</Project>

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

@@ -0,0 +1,29 @@
+// 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;
+
+public class BidTrace(
+    ulong slot,
+    Hash256 blockHash,
+    PublicKey builderPublicKey,
+    PublicKey proposerPublicKey,
+    Address proposerFeeRecipient,
+    long gasLimit,
+    long gasUsed,
+    UInt256 value)
+{
+    public ulong Slot { get; } = slot;
+    public required Hash256 ParentHash { get; set; }
+    public Hash256 BlockHash { get; } = blockHash;
+    public PublicKey BuilderPublicKey { get; } = builderPublicKey;
+    public PublicKey ProposerPublicKey { get; } = proposerPublicKey;
+    public Address ProposerFeeRecipient { get; } = proposerFeeRecipient;
+    public long GasLimit { get; } = gasLimit;
+    public long GasUsed { get; } = gasUsed;
+    public UInt256 Value { get; } = 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>.Success(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";
+}

src/Nethermind/Nethermind.Flashbots/Data/BuilderBlockValidationRequest.cs

@@ -0,0 +1,24 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System.Text.Json.Serialization;
+using Nethermind.Core.Crypto;
+using Nethermind.JsonRpc;
+
+namespace Nethermind.Flashbots.Data;
+
+public class BuilderBlockValidationRequest
+{
+    /// <summary>
+    /// The block hash of the parent beacon block.
+    /// <see cref=https://github.com/flashbots/builder/blob/df9c765067d57ab4b2d0ad39dbb156cbe4965778/eth/block-validation/api.go#L198"/>
+    /// </summary>
+    [JsonRequired]
+    public required Hash256 ParentBeaconBlockRoot { get; set; }
+
+    [JsonRequired]
+    public long RegisterGasLimit { get; set; }
+
+    [JsonRequired]
+    public required SubmitBlockRequest BlockRequest { get; set; }
+}

src/Nethermind/Nethermind.Flashbots/Data/SubmitBlockRequest.cs

@@ -0,0 +1,23 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using Nethermind.Core.Crypto;
+using Nethermind.Merge.Plugin.Data;
+
+namespace Nethermind.Flashbots.Data;
+
+public class SubmitBlockRequest
+{
+    private readonly ExecutionPayload _executionPayload;
+    private readonly BlobsBundleV1 _blobsBundle;
+
+    public SubmitBlockRequest(ExecutionPayload executionPayload, BlobsBundleV1 blobsBundle, BidTrace message)
+    {
+        _executionPayload = executionPayload;
+        _blobsBundle = blobsBundle;
+        Message = message;
+    }
+    public ExecutionPayload ExecutionPayload => _executionPayload;
+    public BlobsBundleV1 BlobsBundle => _blobsBundle;
+    public BidTrace Message { get; }
+}