Implement EIP-7805 (FOCIL)

src/Nethermind/Nethermind.Blockchain.Test/Validators/InclusionListValidatorTests.cs

@@ -0,0 +1,116 @@
+// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using Nethermind.Consensus.Validators;
+using Nethermind.Core;
+using Nethermind.Core.Extensions;
+using Nethermind.Core.Specs;
+using Nethermind.Core.Test.Builders;
+using Nethermind.Evm;
+using Nethermind.Evm.Tracing;
+using Nethermind.Evm.TransactionProcessing;
+using Nethermind.Serialization.Rlp;
+using Nethermind.Specs.Forks;
+using Nethermind.Specs.Test;
+using NSubstitute;
+using NUnit.Framework;
+
+namespace Nethermind.Blockchain.Test.Validators;
+
+public class InclusionListValidatorTests
+{
+    private ITransactionProcessor _transactionProcessor;
+    private ISpecProvider _specProvider;
+    private InclusionListValidator _inclusionListValidator;
+    private Transaction _validTx;
+    private byte[] _validTxBytes;
+
+    [SetUp]
+    public void Setup()
+    {
+        _transactionProcessor = Substitute.For<ITransactionProcessor>();
+        _specProvider = new CustomSpecProvider(((ForkActivation)0, Osaka.Instance));
+        _inclusionListValidator = new InclusionListValidator(
+            _specProvider,
+            _transactionProcessor);
+
+        _validTx = Build.A.Transaction
+            .WithGasLimit(100_000)
+            .WithGasPrice(10.GWei())
+            .WithNonce(1)
+            .WithValue(100.Ether())
+            .WithTo(TestItem.AddressA)
+            .SignedAndResolved(TestItem.PrivateKeyA)
+            .TestObject;
+
+        _validTxBytes = Rlp.Encode(_validTx).Bytes;
+    }
+
+    [Test]
+    public void When_block_full_then_accept()
+    {
+        var block = Build.A.Block
+            .WithGasLimit(30_000_000)
+            .WithGasUsed(30_000_000)
+            .WithInclusionListTransactions([_validTxBytes])
+            .TestObject;
+
+        bool isValid = _inclusionListValidator.ValidateInclusionList(block, out string? error);
+        Assert.That(isValid, Is.True);
+        Assert.That(error, Is.Null);
+    }
+
+    [Test]
+    public void When_all_inclusion_list_txs_included_then_accept()
+    {
+        var block = Build.A.Block
+            .WithGasLimit(30_000_000)
+            .WithGasUsed(1_000_000)
+            .WithTransactions(_validTx)
+            .WithInclusionListTransactions([_validTxBytes])
+            .TestObject;
+
+        bool isValid = _inclusionListValidator.ValidateInclusionList(block, out string? error);
+        Assert.Multiple(() =>
+        {
+            Assert.That(isValid, Is.True);
+            Assert.That(error, Is.Null);
+        });
+    }
+
+    [Test]
+    public void When_valid_tx_excluded_then_reject()
+    {
+        _transactionProcessor.BuildUp(Arg.Any<Transaction>(), Arg.Any<BlockExecutionContext>(), Arg.Any<ITxTracer>())
+            .Returns(TransactionResult.Ok);
+
+        var block = Build.A.Block
+            .WithGasLimit(30_000_000)
+            .WithGasUsed(1_000_000)
+            .WithInclusionListTransactions([_validTxBytes])
+            .TestObject;
+
+        bool isValid = _inclusionListValidator.ValidateInclusionList(block, out string? error);
+        Assert.Multiple(() =>
+        {
+            Assert.That(isValid, Is.False);
+            Assert.That(error, Is.EqualTo("Block excludes valid inclusion list transaction"));
+        });
+    }
+
+    [Test]
+    public void When_no_inclusion_list_then_reject()
+    {
+        var block = Build.A.Block
+            .WithGasLimit(30_000_000)
+            .WithGasUsed(1_000_000)
+            .TestObject;
+
+        bool isValid = _inclusionListValidator.ValidateInclusionList(block, out string? error);
+        Assert.Multiple(() =>
+        {
+            Assert.That(isValid, Is.False);
+            Assert.That(error, Is.EqualTo("Block did not have inclusion list"));
+        });
+    }
+}

src/Nethermind/Nethermind.Consensus/EngineApiVersions.cs

@@ -9,4 +9,5 @@ public static class EngineApiVersions
     public const int Shanghai = 2;
     public const int Cancun = 3;
     public const int Prague = 4;
+    public const int Osaka = 5;
 }

src/Nethermind/Nethermind.Consensus/Messages/BlockErrorMessages.cs

@@ -123,7 +123,7 @@ public static string HeaderBlobGasMismatch(ulong? expected, ulong? actual) =>
         "RequestsNotEnabled: Requests must be null in block when EIP-6110 and EIP-7002 are not activated.";
 
     public static string InvalidRequestsHash(Hash256? expected, Hash256? actual) =>
-        $"InvalidRequestsHash: Requests hash hash mismatch in block: expected {expected}, got {actual}";
+        $"InvalidRequestsHash: Requests hash mismatch in block: expected {expected}, got {actual}";
 
     public const string InvalidRequestsOrder =
         "InvalidRequestsOrder: Requests are not in the correct order in block.";

src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs

@@ -62,6 +62,8 @@ public partial class BlockProcessor(
     private readonly IBlockProcessor.IBlockTransactionsExecutor _blockTransactionsExecutor = blockTransactionsExecutor ?? throw new ArgumentNullException(nameof(blockTransactionsExecutor));
     private readonly IBlockhashStore _blockhashStore = blockHashStore ?? throw new ArgumentNullException(nameof(blockHashStore));
     private readonly IExecutionRequestsProcessor _executionRequestsProcessor = executionRequestsProcessor ?? new ExecutionRequestsProcessor(transactionProcessor);
+    private readonly ITransactionProcessor _transactionProcessor = transactionProcessor ?? throw new ArgumentNullException(nameof(transactionProcessor));
+    private readonly IInclusionListValidator _inclusionListValidator = new InclusionListValidator(specProvider, transactionProcessor);
     private Task _clearTask = Task.CompletedTask;
 
     private const int MaxUncommittedBlocks = 64;
@@ -296,7 +298,12 @@ private void RestoreBranch(Hash256 branchingPointStateRoot)
     // TODO: block processor pipeline
     private void ValidateProcessedBlock(Block suggestedBlock, ProcessingOptions options, Block block, TxReceipt[] receipts)
     {
-        if (!options.ContainsFlag(ProcessingOptions.NoValidation) && !_blockValidator.ValidateProcessedBlock(block, receipts, suggestedBlock, out string? error))
+        block.InclusionListTransactions = suggestedBlock.InclusionListTransactions;
+
+        if (
+            !options.ContainsFlag(ProcessingOptions.NoValidation) &&
+            (!_blockValidator.ValidateProcessedBlock(block, receipts, suggestedBlock, out string? error) ||
+            !_inclusionListValidator.ValidateInclusionList(block, out error)))
         {
             if (_logger.IsWarn) _logger.Warn(InvalidBlockHelper.GetMessage(suggestedBlock, "invalid block after processing"));
             throw new InvalidBlockException(suggestedBlock, error);

src/Nethermind/Nethermind.Consensus/Producers/BlockProducerBase.cs

@@ -252,7 +252,7 @@ protected virtual Block PrepareBlock(BlockHeader parent, PayloadAttributes? payl
 
             IEnumerable<Transaction> transactions = _txSource.GetTransactions(parent, header.GasLimit, payloadAttributes);
 
-            return new BlockToProduce(header, transactions, Array.Empty<BlockHeader>(), payloadAttributes?.Withdrawals);
+            return new BlockToProduce(header, transactions, Array.Empty<BlockHeader>(), payloadAttributes?.Withdrawals, payloadAttributes?.InclusionListTransactions);
         }
     }
 }

src/Nethermind/Nethermind.Consensus/Producers/BlockProducerEnvFactory.cs

@@ -123,7 +123,8 @@ protected virtual ITxSource CreateTxSourceForProducer(
             ILogManager logManager)
         {
             TxPoolTxSource txPoolSource = CreateTxPoolTxSource(processingEnv, txPool, blocksConfig, transactionComparerProvider, logManager);
-            return additionalTxSource.Then(txPoolSource);
+            InclusionListTxSource inclusionListTxSource = new(_specProvider.ChainId);
+            return additionalTxSource.Then(txPoolSource).Then(inclusionListTxSource);
         }
 
         protected virtual TxPoolTxSource CreateTxPoolTxSource(
@@ -132,13 +133,7 @@ protected virtual TxPoolTxSource CreateTxPoolTxSource(
             IBlocksConfig blocksConfig,
             ITransactionComparerProvider transactionComparerProvider,
             ILogManager logManager)
-        {
-            ITxFilterPipeline txSourceFilterPipeline = CreateTxSourceFilter(blocksConfig);
-            return new TxPoolTxSource(txPool, _specProvider, transactionComparerProvider, logManager, txSourceFilterPipeline);
-        }
-
-        protected virtual ITxFilterPipeline CreateTxSourceFilter(IBlocksConfig blocksConfig) =>
-            TxFilterPipelineBuilder.CreateStandardFilteringPipeline(_logManager, _specProvider, blocksConfig);
+            => new TxPoolTxSourceFactory(txPool, _specProvider, transactionComparerProvider, blocksConfig, logManager).Create();
 
         protected virtual BlockProcessor CreateBlockProcessor(
             IReadOnlyTxProcessingScope readOnlyTxProcessingEnv,

src/Nethermind/Nethermind.Consensus/Producers/BlockToProduce.cs

@@ -32,10 +32,10 @@ public class BlockToProduce : Block
         public BlockToProduce(BlockHeader blockHeader,
             IEnumerable<Transaction> transactions,
             IEnumerable<BlockHeader> uncles,
-            IEnumerable<Withdrawal>? withdrawals = null)
-            : base(blockHeader, Array.Empty<Transaction>(), uncles, withdrawals)
+            IEnumerable<Withdrawal>? withdrawals = null,
+            IEnumerable<byte[]>? inclusionListTransactions = null)
+            : base(blockHeader, transactions, uncles, withdrawals, inclusionListTransactions)
         {
-            Transactions = transactions;
         }
 
         public override Block WithReplacedHeader(BlockHeader newHeader) => new BlockToProduce(newHeader, Transactions, Uncles, Withdrawals);

src/Nethermind/Nethermind.Consensus/Producers/PayloadAttributes.cs

@@ -11,6 +11,8 @@
 using Nethermind.Core.Specs;
 using Nethermind.State.Proofs;
 using Nethermind.Trie;
+using System.Linq;
+using Nethermind.Serialization.Rlp;
 
 namespace Nethermind.Consensus.Producers;
 
@@ -26,6 +28,8 @@ public class PayloadAttributes
 
     public Hash256? ParentBeaconBlockRoot { get; set; }
 
+    public byte[][]? InclusionListTransactions { get; set; }
+
     public virtual long? GetGasLimit() => null;
 
     public override string ToString() => ToString(string.Empty);
@@ -47,6 +51,11 @@ public string ToString(string indentation)
             sb.Append($", {nameof(ParentBeaconBlockRoot)} : {ParentBeaconBlockRoot}");
         }
 
+        if (InclusionListTransactions is not null)
+        {
+            sb.Append($", {nameof(InclusionListTransactions)} count: {InclusionListTransactions.Length}");
+        }
+
         sb.Append('}');
 
         return sb.ToString();
@@ -71,7 +80,8 @@ protected virtual int ComputePayloadIdMembersSize() =>
         + Keccak.Size // prev randao
         + Address.Size // suggested fee recipient
         + (Withdrawals is null ? 0 : Keccak.Size) // withdrawals root hash
-        + (ParentBeaconBlockRoot is null ? 0 : Keccak.Size); // parent beacon block root
+        + (ParentBeaconBlockRoot is null ? 0 : Keccak.Size) // parent beacon block root
+        + (InclusionListTransactions is null ? 0 : Keccak.Size); // inclusion list transactions root hash
 
     protected static string ComputePayloadId(Span<byte> inputSpan)
     {
@@ -110,6 +120,16 @@ protected virtual int WritePayloadIdMembers(BlockHeader parentHeader, Span<byte>
             position += Keccak.Size;
         }
 
+        if (InclusionListTransactions is not null)
+        {
+            Transaction[] txs = InclusionListTransactions.Select(tx => Rlp.Decode<Transaction>(tx)).ToArray();
+            Hash256 inclusionListTransactionsRootHash = InclusionListTransactions.Length == 0
+                ? PatriciaTree.EmptyTreeHash
+                : new TxTrie(txs).RootHash;
+            inclusionListTransactionsRootHash.Bytes.CopyTo(inputSpan.Slice(position, Keccak.Size));
+            position += Keccak.Size;
+        }
+
         return position;
     }
 
@@ -166,6 +186,7 @@ public static class PayloadAttributesExtensions
     public static int GetVersion(this PayloadAttributes executionPayload) =>
         executionPayload switch
         {
+            { InclusionListTransactions: not null } => EngineApiVersions.Osaka,
             { ParentBeaconBlockRoot: not null, Withdrawals: not null } => EngineApiVersions.Cancun,
             { Withdrawals: not null } => EngineApiVersions.Shanghai,
             _ => EngineApiVersions.Paris
@@ -174,6 +195,7 @@ public static int GetVersion(this PayloadAttributes executionPayload) =>
     public static int ExpectedPayloadAttributesVersion(this IReleaseSpec spec) =>
         spec switch
         {
+            { IsEip7805Enabled: true } => EngineApiVersions.Osaka,
             { IsEip4844Enabled: true } => EngineApiVersions.Cancun,
             { WithdrawalsEnabled: true } => EngineApiVersions.Shanghai,
             _ => EngineApiVersions.Paris

src/Nethermind/Nethermind.Consensus/Producers/TxPoolTxSourceFactory.cs

@@ -0,0 +1,41 @@
+// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using Nethermind.Config;
+using Nethermind.Consensus.Comparers;
+using Nethermind.Consensus.Transactions;
+using Nethermind.Core.Specs;
+using Nethermind.Logging;
+using Nethermind.TxPool;
+
+namespace Nethermind.Consensus.Producers
+{
+    public class TxPoolTxSourceFactory
+    {
+        private readonly ITxPool _txPool;
+        private readonly ISpecProvider _specProvider;
+        private readonly ITransactionComparerProvider _transactionComparerProvider;
+        private readonly IBlocksConfig _blocksConfig;
+        private readonly ILogManager _logManager;
+
+        public TxPoolTxSourceFactory(
+            ITxPool txPool,
+            ISpecProvider specProvider,
+            ITransactionComparerProvider transactionComparerProvider,
+            IBlocksConfig blocksConfig,
+            ILogManager logManager)
+        {
+            _txPool = txPool;
+            _specProvider = specProvider;
+            _transactionComparerProvider = transactionComparerProvider;
+            _blocksConfig = blocksConfig;
+            _logManager = logManager;
+        }
+
+        public virtual TxPoolTxSource Create()
+        {
+            ITxFilterPipeline txSourceFilterPipeline = TxFilterPipelineBuilder.CreateStandardFilteringPipeline(_logManager, _specProvider, _blocksConfig);
+            return new TxPoolTxSource(_txPool, _specProvider, _transactionComparerProvider, _logManager, txSourceFilterPipeline);
+        }
+    }
+}

src/Nethermind/Nethermind.Consensus/Transactions/InclusionListTxSource.cs

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Nethermind.Consensus.Producers;
+using Nethermind.Core;
+using Nethermind.Crypto;
+using Nethermind.Serialization.Rlp;
+
+namespace Nethermind.Consensus.Transactions;
+
+public class InclusionListTxSource(ulong chainId) : ITxSource
+{
+    private readonly EthereumEcdsa _ecdsa = new(chainId);
+
+    public IEnumerable<Transaction> GetTransactions(BlockHeader parent, long gasLimit, PayloadAttributes? payloadAttributes = null)
+        => payloadAttributes?.InclusionListTransactions?.Select(tx => DecodeTransaction(tx)) ?? [];
+
+    private Transaction DecodeTransaction(ReadOnlySpan<byte> txBytes)
+    {
+        Transaction tx = TxDecoder.Instance.Decode(txBytes, RlpBehaviors.SkipTypedWrapping);
+        tx.SenderAddress = _ecdsa.RecoverAddress(tx, true);
+        return tx;
+    }
+}

src/Nethermind/Nethermind.Consensus/Validators/IInclusionListValidator.cs

@@ -0,0 +1,36 @@
+// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using Nethermind.Core;
+
+namespace Nethermind.Consensus.Validators;
+
+public interface IInclusionListValidator
+{
+    /// <summary>
+    /// Validates that the block satisfies the inclusion list
+    /// the <see href="https://eips.ethereum.org/EIPS/eip-7805">EIP-7805</see>.
+    /// </summary>
+    /// <param name="inclusionListTransactions">The inclusion list transactions to validate.</param>
+    /// <param name="block">The block to validate.</param>
+    /// <param name="error">The validation error message if any.</param>
+    /// <returns>
+    /// <c>true</c> if the block's inclusion list is satisfied according to EIP-7805;
+    /// otherwise, <c>false</c>.
+    /// </returns>
+    bool ValidateInclusionList(Block block)
+        => ValidateInclusionList(block, out _);
+
+    /// <summary>
+    /// Validates that the block satisfies the inclusion list
+    /// the <see href="https://eips.ethereum.org/EIPS/eip-7805">EIP-7805</see>.
+    /// </summary>
+    /// <param name="inclusionListTransactions">The inclusion list transactions to validate.</param>
+    /// <param name="block">The block to validate.</param>
+    /// <param name="error">The validation error message if any.</param>
+    /// <returns>
+    /// <c>true</c> if the block's inclusion list is satisfied according to EIP-7805;
+    /// otherwise, <c>false</c>.
+    /// </returns>
+    bool ValidateInclusionList(Block block, out string? error);
+}