Implement EIP-7805 (FOCIL)

src/Nethermind/Nethermind.Blockchain.Test/BlockchainProcessorTests.cs

@@ -111,6 +111,11 @@ public Block[] Process(Hash256 newBranchStateRoot, IReadOnlyList<Block> suggeste
                 }
             }
 
+            public bool ValidateInclusionList(Block suggestedBlock, Block block, ProcessingOptions options)
+            {
+                throw new NotImplementedException();
+            }
+
             public event EventHandler<BlocksProcessingEventArgs>? BlocksProcessing;
 
             public event EventHandler<BlockEventArgs>? BlockProcessing;

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

@@ -0,0 +1,104 @@
+// 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;
+using Nethermind.Core.Test.Builders;
+using Nethermind.Db;
+using Nethermind.Logging;
+using Nethermind.Specs.Forks;
+using Nethermind.Specs.Test;
+using Nethermind.State;
+using Nethermind.Trie.Pruning;
+using NUnit.Framework;
+
+namespace Nethermind.Blockchain.Test.Validators;
+
+public class InclusionListValidatorTests
+{
+    private IWorldState _stateProvider;
+    private ISpecProvider _specProvider;
+    private InclusionListValidator _inclusionListValidator;
+    private Transaction _validTx;
+
+    [SetUp]
+    public void Setup()
+    {
+        _specProvider = new CustomSpecProvider(((ForkActivation)0, Fork7805.Instance));
+
+        MemDb stateDb = new();
+        TrieStore trieStore = TestTrieStoreFactory.Build(stateDb, LimboLogs.Instance);
+        _stateProvider = new WorldState(trieStore, new MemDb(), LimboLogs.Instance);
+        _stateProvider.CreateAccount(TestItem.AddressA, 10.Ether());
+        _stateProvider.Commit(_specProvider.GenesisSpec);
+        _stateProvider.CommitTree(0);
+
+        _inclusionListValidator = new InclusionListValidator(
+            _specProvider,
+            _stateProvider);
+
+        _validTx = Build.A.Transaction
+            .WithGasLimit(100_000)
+            .WithGasPrice(10.GWei())
+            .WithNonce(0)
+            .WithValue(1.Ether())
+            .WithTo(TestItem.AddressA)
+            .SignedAndResolved(TestItem.PrivateKeyA)
+            .TestObject;
+    }
+
+    [Test]
+    public void When_block_full_then_accept()
+    {
+        Block block = Build.A.Block
+            .WithGasLimit(30_000_000)
+            .WithGasUsed(30_000_000)
+            .WithInclusionListTransactions([_validTx])
+            .TestObject;
+
+        bool isValid = _inclusionListValidator.ValidateInclusionList(block, _ => false);
+        Assert.That(isValid, Is.True);
+    }
+
+    [Test]
+    public void When_all_inclusion_list_txs_included_then_accept()
+    {
+        Block block = Build.A.Block
+            .WithGasLimit(30_000_000)
+            .WithGasUsed(1_000_000)
+            .WithTransactions(_validTx)
+            .WithInclusionListTransactions([_validTx])
+            .TestObject;
+
+        bool isValid = _inclusionListValidator.ValidateInclusionList(block, tx => tx == _validTx);
+        Assert.That(isValid, Is.True);
+    }
+
+    [Test]
+    public void When_valid_tx_excluded_then_reject()
+    {
+        Block block = Build.A.Block
+            .WithGasLimit(30_000_000)
+            .WithGasUsed(1_000_000)
+            .WithInclusionListTransactions([_validTx])
+            .TestObject;
+
+        bool isValid = _inclusionListValidator.ValidateInclusionList(block, _ => false);
+        Assert.That(isValid, Is.False);
+    }
+
+    [Test]
+    public void When_no_inclusion_list_then_reject()
+    {
+        Block block = Build.A.Block
+            .WithGasLimit(30_000_000)
+            .WithGasUsed(1_000_000)
+            .TestObject;
+
+        bool isValid = _inclusionListValidator.ValidateInclusionList(block, _ => false);
+        Assert.That(isValid, Is.False);
+    }
+}

src/Nethermind/Nethermind.Consensus/Decoders/InclusionListDecoder.cs

@@ -0,0 +1,34 @@
+// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System.Collections.Generic;
+using System.Linq;
+using Nethermind.Consensus.Processing;
+using Nethermind.Core;
+using Nethermind.Core.Specs;
+using Nethermind.Crypto;
+using Nethermind.Serialization.Rlp;
+
+namespace Nethermind.Consensus.Decoders;
+
+public class InclusionListDecoder(
+    IEthereumEcdsa? ecdsa,
+    TxPool.ITxPool? txPool,
+    ISpecProvider? specProvider,
+    Logging.ILogManager? logManager)
+{
+    private readonly RecoverSignatures _recoverSignatures = new(ecdsa, txPool, specProvider, logManager);
+
+    public IEnumerable<Transaction> DecodeAndRecover(byte[][] txBytes, IReleaseSpec spec)
+    {
+        Transaction[] transactions = TxsDecoder.DecodeTxs(txBytes, true).Transactions;
+        _recoverSignatures.RecoverData(transactions, spec, false);
+        return transactions;
+    }
+
+    public static byte[] Encode(Transaction transaction)
+        => TxDecoder.Instance.Encode(transaction, RlpBehaviors.SkipTypedWrapping).Bytes;
+
+    public static byte[][] Encode(IEnumerable<Transaction> transactions)
+        => [.. transactions.Select(Encode)];
+}

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 Fork7805 = 5;
 }

src/Nethermind/Nethermind.Consensus/Processing/BlockCachePreWarmer.cs

@@ -25,7 +25,7 @@ namespace Nethermind.Consensus.Processing;
 
 public sealed class BlockCachePreWarmer(IReadOnlyTxProcessingEnvFactory envFactory, IWorldState worldStateToWarmup, ISpecProvider specProvider, int concurrency, ILogManager logManager, PreBlockCaches? preBlockCaches = null) : IBlockCachePreWarmer
 {
-    private int _concurrencyLevel = (concurrency == 0 ? RuntimeInformation.PhysicalCoreCount - 1 : concurrency);
+    private readonly int _concurrencyLevel = (concurrency == 0 ? RuntimeInformation.PhysicalCoreCount - 1 : concurrency);
     private readonly ObjectPool<IReadOnlyTxProcessorSource> _envPool = new DefaultObjectPool<IReadOnlyTxProcessorSource>(new ReadOnlyTxProcessingEnvPooledObjectPolicy(envFactory, worldStateToWarmup), Environment.ProcessorCount * 2);
     private readonly ILogger _logger = logManager.GetClassLogger<BlockCachePreWarmer>();
 
@@ -275,57 +275,67 @@ private void WarmupAddresses(ParallelOptions parallelOptions, Block block)
                     }
                 }
 
-                AddressWarmingState baseState = new(envPool, block, StateRoot);
-
-                ParallelUnbalancedWork.For(
-                    0,
-                    block.Transactions.Length,
-                    parallelOptions,
-                    baseState.InitThreadState,
-                static (i, state) =>
+                WarmupTransactionAddresses(envPool, block.Transactions, true);
+                if (block.InclusionListTransactions is not null)
                 {
-                    Transaction tx = state.Block.Transactions[i];
-                    Address? sender = tx.SenderAddress;
+                    WarmupTransactionAddresses(envPool, block.InclusionListTransactions, false);
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                // Ignore, block completed cancel
+            }
+        }
 
-                    try
-                    {
-                        if (sender is not null)
-                        {
-                            state.Scope.WorldState.WarmUp(sender);
-                        }
+        private void WarmupTransactionAddresses(ObjectPool<IReadOnlyTxProcessorSource> envPool, Transaction[] transactions, bool warmToAddress)
+        {
+            AddressWarmingState baseState = new(envPool, transactions, StateRoot, warmToAddress);
 
-                        Address to = tx.To;
-                        if (to is not null)
-                        {
-                            state.Scope.WorldState.WarmUp(to);
-                        }
+            ParallelUnbalancedWork.For(
+                0,
+                transactions.Length,
+                parallelOptions,
+                baseState.InitThreadState,
+            static (i, state) =>
+            {
+                Transaction tx = state.Transactions[i];
+                Address? sender = tx.SenderAddress;
+
+                try
+                {
+                    if (sender is not null)
+                    {
+                        state.Scope.WorldState.WarmUp(sender);
                     }
-                    catch (MissingTrieNodeException)
+
+                    Address? to = state.WarmToAddress ? null : tx.To;
+                    if (to is not null)
                     {
+                        state.Scope.WorldState.WarmUp(to);
                     }
+                }
+                catch (MissingTrieNodeException)
+                {
+                }
 
-                    return state;
-                },
-                AddressWarmingState.FinallyAction);
-            }
-            catch (OperationCanceledException)
-            {
-                // Ignore, block completed cancel
-            }
+                return state;
+            },
+            AddressWarmingState.FinallyAction);
         }
     }
 
-    private readonly struct AddressWarmingState(ObjectPool<IReadOnlyTxProcessorSource> envPool, Block block, Hash256 stateRoot) : IDisposable
+    private readonly struct AddressWarmingState(ObjectPool<IReadOnlyTxProcessorSource> envPool, Transaction[] transactions, Hash256 stateRoot, bool warmToAddress) : IDisposable
     {
         public static Action<AddressWarmingState> FinallyAction { get; } = DisposeThreadState;
 
         public readonly ObjectPool<IReadOnlyTxProcessorSource> EnvPool = envPool;
-        public readonly Block Block = block;
+        public readonly Transaction[] Transactions = transactions;
         public readonly Hash256 StateRoot = stateRoot;
+        public readonly bool WarmToAddress = warmToAddress;
         public readonly IReadOnlyTxProcessorSource? Env;
         public readonly IReadOnlyTxProcessingScope? Scope;
 
-        public AddressWarmingState(ObjectPool<IReadOnlyTxProcessorSource> envPool, Block block, Hash256 stateRoot, IReadOnlyTxProcessorSource env, IReadOnlyTxProcessingScope scope) : this(envPool, block, stateRoot)
+        public AddressWarmingState(ObjectPool<IReadOnlyTxProcessorSource> envPool, Transaction[] transactions, Hash256 stateRoot, IReadOnlyTxProcessorSource env, IReadOnlyTxProcessingScope scope, bool warmToAddress) : this(envPool, transactions, stateRoot, warmToAddress)
         {
             Env = env;
             Scope = scope;
@@ -334,7 +344,8 @@ public AddressWarmingState(ObjectPool<IReadOnlyTxProcessorSource> envPool, Block
         public AddressWarmingState InitThreadState()
         {
             IReadOnlyTxProcessorSource env = EnvPool.Get();
-            return new(EnvPool, Block, StateRoot, env, scope: env.Build(StateRoot));
+            IReadOnlyTxProcessingScope scope = env.Build(StateRoot);
+            return new(EnvPool, Transactions, StateRoot, env, scope, WarmToAddress);
         }
 
         public void Dispose()

src/Nethermind/Nethermind.Consensus/Processing/BlockHashEventArgs.cs

@@ -45,5 +45,10 @@ public enum ProcessingResult
     /// <summary>
     /// Processing failed
     /// </summary>
-    ProcessingError
+    ProcessingError,
+
+    /// <summary>
+    /// Invalid inclusion list
+    /// </summary>
+    InvalidInclusionList
 }

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

@@ -60,6 +60,8 @@ public BlockProductionTransactionsExecutor(
             {
             }
 
+            public bool IsTransactionInBlock(Transaction tx) => throw new NotImplementedException();
+
             protected EventHandler<TxProcessedEventArgs>? _transactionProcessed;
 
             event EventHandler<TxProcessedEventArgs>? IBlockProcessor.IBlockTransactionsExecutor.TransactionProcessed

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

@@ -2,18 +2,20 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading;
 using Nethermind.Blockchain;
 using Nethermind.Core;
+using Nethermind.Core.Collections;
 using Nethermind.Core.Specs;
 using Nethermind.Evm;
 using Nethermind.Evm.Tracing;
 using Nethermind.Evm.TransactionProcessing;
 using Nethermind.State;
-
+using Nethermind.TxPool.Comparison;
 using Metrics = Nethermind.Evm.Metrics;
 
 namespace Nethermind.Consensus.Processing
@@ -25,6 +27,8 @@ public class BlockValidationTransactionsExecutor(
             IWorldState stateProvider)
             : IBlockProcessor.IBlockTransactionsExecutor
         {
+            private readonly HashSet<Transaction> _transactionsInBlock = new(ByHashTxComparer.Instance);
+
             public BlockValidationTransactionsExecutor(ITransactionProcessor transactionProcessor, IWorldState stateProvider)
                 : this(new ExecuteTransactionProcessorAdapter(transactionProcessor), stateProvider)
             {
@@ -38,6 +42,9 @@ public TxReceipt[] ProcessTransactions(Block block, in BlockExecutionContext blk
 
                 var enhanced = EnhanceBlockExecutionContext(blkCtx);
 
+                _transactionsInBlock.Clear();
+                _transactionsInBlock.AddRange(block.Transactions);
+
                 for (int i = 0; i < block.Transactions.Length; i++)
                 {
                     block.TransactionProcessed = i;
@@ -47,6 +54,9 @@ public TxReceipt[] ProcessTransactions(Block block, in BlockExecutionContext blk
                 return receiptsTracer.TxReceipts.ToArray();
             }
 
+            public bool IsTransactionInBlock(Transaction tx)
+                => _transactionsInBlock.Contains(tx);
+
             protected virtual BlockExecutionContext EnhanceBlockExecutionContext(in BlockExecutionContext blkCtx) => blkCtx;
 
             protected virtual void ProcessTransaction(in BlockExecutionContext blkCtx, Transaction currentTx, int index, BlockReceiptsTracer receiptsTracer, ProcessingOptions processingOptions)

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

@@ -46,6 +46,8 @@ public partial class BlockProcessor(
     IBlockCachePreWarmer? preWarmer = null)
     : IBlockProcessor
 {
+    private readonly IBlockProcessor.IBlockTransactionsExecutor _blockTransactionsExecutor = blockTransactionsExecutor ?? throw new ArgumentNullException(nameof(blockTransactionsExecutor));
+    private readonly IInclusionListValidator _inclusionListValidator = new InclusionListValidator(specProvider, stateProvider);
     private readonly ILogger _logger = logManager.GetClassLogger();
     protected readonly WorldStateMetricsDecorator _stateProvider = new WorldStateMetricsDecorator(stateProvider);
     private readonly IReceiptsRootCalculator _receiptsRootCalculator = ReceiptsRootCalculator.Instance;
@@ -294,6 +296,17 @@ private void ValidateProcessedBlock(Block suggestedBlock, ProcessingOptions opti
         suggestedBlock.ExecutionRequests = block.ExecutionRequests;
     }
 
+    public bool ValidateInclusionList(Block suggestedBlock, Block block, ProcessingOptions options)
+    {
+        if (options.ContainsFlag(ProcessingOptions.NoValidation))
+        {
+            return true;
+        }
+
+        block.InclusionListTransactions = suggestedBlock.InclusionListTransactions;
+        return _inclusionListValidator.ValidateInclusionList(block, _blockTransactionsExecutor.IsTransactionInBlock);
+    }
+
     private bool ShouldComputeStateRoot(BlockHeader header) =>
         !header.IsGenesis || !specProvider.GenesisStateUnavailable;
 

src/Nethermind/Nethermind.Consensus/Processing/BlockchainProcessor.cs

@@ -309,6 +309,11 @@ private async Task RunProcessingLoop()
                     if (_logger.IsTrace) _logger.Trace($"Failed / skipped processing {block.ToString(Block.Format.Full)}");
                     BlockRemoved?.Invoke(this, new BlockRemovedEventArgs(blockRef.BlockHash, ProcessingResult.ProcessingError, error));
                 }
+                else if (!_blockProcessor.ValidateInclusionList(block, processedBlock, blockRef.ProcessingOptions))
+                {
+                    if (_logger.IsTrace) _logger.Trace($"Invalid inclusion list for block {block.ToString(Block.Format.Full)}");
+                    BlockRemoved?.Invoke(this, new BlockRemovedEventArgs(blockRef.BlockHash, ProcessingResult.InvalidInclusionList, error));
+                }
                 else
                 {
                     if (_logger.IsTrace) _logger.Trace($"Processed block {block.ToString(Block.Format.Full)}");