Implement EIP-7805 (FOCIL)

src/Nethermind/Ethereum.Blockchain.Pyspec.Test/Constants.cs

@@ -8,4 +8,8 @@ public class Constants
     public const string ARCHIVE_URL_TEMPLATE = "https://github.com/ethereum/execution-specs/releases/download/{0}/{1}";
     public const string DEFAULT_ARCHIVE_VERSION = "tests-glamsterdam-devnet@v6.1.1";
     public const string DEFAULT_ARCHIVE_NAME = "fixtures_glamsterdam-devnet.tar.gz";
+
+    // EIP-7805 (FOCIL) fixtures for Bogota — shipped as a separate archive from the default release.
+    public const string FOCIL_ARCHIVE_VERSION = "tests-focil@v0.1.0";
+    public const string FOCIL_ARCHIVE_NAME = "fixtures_focil.tar.gz";
 }

src/Nethermind/Ethereum.Blockchain.Pyspec.Test/PyspecTestFixture.cs

@@ -67,6 +67,23 @@ public static IEnumerable<TestCaseData> LoadTests() =>
         PyspecLoader.LoadCases<BlockchainTest, TSelf>("blockchain_tests_sync", "SyncBlockchainTests");
 }
 
+// Bogota engine-payload fixtures (EIP-7805 FOCIL). Shipped as a separate EELS release archive
+// from BAL, so we override ArchiveVersion/ArchiveName here.
+public abstract class PyspecBogotaEngineBlockchainTestFixture() : PyspecLinuxX64BlockchainFixture(parallel: false, batchRead: false)
+{
+    [TestCaseSource(nameof(LoadTests))]
+    public async Task Test(BlockchainTest test) => Assert.That((await RunTest(test)).Pass, Is.True);
+
+    public static IEnumerable<TestCaseData> LoadTests() =>
+        PyspecLoader.ToTestCases(new TestsSourceLoader(
+            new LoadPyspecTestsStrategy
+            {
+                ArchiveVersion = Constants.FOCIL_ARCHIVE_VERSION,
+                ArchiveName = Constants.FOCIL_ARCHIVE_NAME,
+            },
+            "fixtures/blockchain_tests_engine/for_bogota").LoadTests<BlockchainTest>());
+}
+
 // Loads only `for_amsterdam` because parallel-BAL execution is gated on EIP-7928.
 public abstract class PyspecAmsterdamBlockchainTestFixture(bool parallel, bool batchRead) : PyspecLinuxX64BlockchainFixture(parallel, batchRead)
 {

src/Nethermind/Ethereum.Blockchain.Pyspec.Test/Tests.cs

@@ -48,6 +48,9 @@ public class Bpo2ToAmsterdamAtTime15kEngineBlockchainTests : PyspecEngineBlockch
 public class Bpo2ToBpo3AtTime15kEngineBlockchainTests : PyspecEngineBlockchainTestFixture<Bpo2ToBpo3AtTime15kEngineBlockchainTests>;
 public class Bpo3ToBpo4AtTime15kEngineBlockchainTests : PyspecEngineBlockchainTestFixture<Bpo3ToBpo4AtTime15kEngineBlockchainTests>;
 
+// EIP-7805 (FOCIL) — Bogota fork. Loads `for_bogota` from the tests-focil release.
+public class BogotaEngineBlockchainTests : PyspecBogotaEngineBlockchainTestFixture;
+
 // Sync blockchain tests - exercise sync-mode payload validation alongside the standard engine flow.
 public class AmsterdamSyncBlockchainTests : PyspecSyncBlockchainTestFixture<AmsterdamSyncBlockchainTests>;
 public class OsakaSyncBlockchainTests : PyspecSyncBlockchainTestFixture<OsakaSyncBlockchainTests>;

src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs

@@ -439,7 +439,11 @@ private static async Task<Result<string>> RunNewPayloads(TestEngineNewPayloadsJs
                 && validationError is null;
 
             int paramCount = NewPayloadParamCounts[newPayloadVersion];
-            string paramsJson = "[" + string.Join(",", enginePayload.Params.Take(paramCount).Select(static p => p.GetRawText())) + "]";
+            IEnumerable<string> paramsRaw = enginePayload.Params.Take(paramCount).Select(static p => p.GetRawText());
+            // EIP-7805 (FOCIL): the IL is a separate fixture field; append it as the 5th positional arg for V6.
+            if (newPayloadVersion >= EngineApiVersions.NewPayload.V6 && enginePayload.InclusionListTransactions is { } il)
+                paramsRaw = paramsRaw.Append(JsonSerializer.Serialize(il));
+            string paramsJson = "[" + string.Join(",", paramsRaw) + "]";
 
             string npMethod = expectWitness ? "engine_newPayloadWithWitness" : "engine_newPayloadV" + newPayloadVersion;
             JsonRpcResponse npResponse = await SendRpc(rpcService, rpcContext, npMethod, paramsJson);
@@ -476,12 +480,14 @@ private static async Task<Result<string>> RunNewPayloads(TestEngineNewPayloadsJs
             else
             {
                 PayloadStatusV1 payloadStatus = GetPayloadStatus(npResponse, newPayloadVersion);
-                AssertPayloadStatus(payloadStatus, validationError, newPayloadVersion);
+                AssertPayloadStatus(payloadStatus, validationError, newPayloadVersion, enginePayload.Status);
                 lastStatus = payloadStatus.Status;
                 if (payloadStatus.ValidationError is not null)
                     lastValidationError = payloadStatus.ValidationError;
 
-                if (payloadStatus.Status == PayloadStatus.Valid)
+                // FCU after INCLUSION_LIST_UNSATISFIED too — the block is committed, so the head
+                // must advance to match the fixture's lastblockhash/postState.
+                if (payloadStatus.Status is PayloadStatus.Valid or PayloadStatus.InclusionListUnsatisfied)
                 {
                     string blockHash = enginePayload.Params[0].GetProperty("blockHash").GetString()!;
                     AssertRpcSuccess(await SendFcu(rpcService, rpcContext, fcuVersion, blockHash));
@@ -523,6 +529,9 @@ private static bool TryGetRpcError(JsonRpcResponse response, out int errorCode,
     private static PayloadStatusV1 GetPayloadStatus(JsonRpcResponse response, int payloadVersion) =>
         response switch
         {
+            // newPayloadV6 (EIP-7805) returns PayloadStatusV2; it derives from PayloadStatusV1 so the
+            // runtime type is preserved and AssertPayloadStatus can read inclusionListSatisfied.
+            ResultWrapper<PayloadStatusV2> { Result.ResultType: ResultType.Success } v2Wrapper => v2Wrapper.Data,
             ResultWrapper<PayloadStatusV1> { Result.ResultType: ResultType.Success } resultWrapper => resultWrapper.Data,
             JsonRpcSuccessResponse { Result: PayloadStatusV1 payloadStatus } => payloadStatus,
             _ => throw new AssertionException($"engine_newPayloadV{payloadVersion} returned unexpected response type {response.GetType().FullName}")
@@ -531,10 +540,19 @@ private static PayloadStatusV1 GetPayloadStatus(JsonRpcResponse response, int pa
     private static void AssertExpectedRpcError(int errorCode, string? errorMessage, string? validationError, int payloadVersion) =>
         Assert.That(validationError, Is.Not.Null, $"engine_newPayloadV{payloadVersion} RPC error: {errorCode} {errorMessage}");
 
-    private static void AssertPayloadStatus(PayloadStatusV1 payloadStatus, string? expectedValidationError, int payloadVersion)
+    private static void AssertPayloadStatus(PayloadStatusV1 payloadStatus, string? expectedValidationError, int payloadVersion, string? explicitStatus = null)
     {
-        string expectedStatus = expectedValidationError is null ? PayloadStatus.Valid : PayloadStatus.Invalid;
-        Assert.That(payloadStatus.Status, Is.EqualTo(expectedStatus), $"engine_newPayloadV{payloadVersion} returned {payloadStatus.Status}, expected {expectedStatus}. ValidationError: {payloadStatus.ValidationError}");
+        // A fixture-supplied `status` wins (covers INCLUSION_LIST_UNSATISFIED for FOCIL);
+        // otherwise fall back to the legacy validation-error → INVALID convention.
+        string expectedStatus = explicitStatus ?? (expectedValidationError is null ? PayloadStatus.Valid : PayloadStatus.Invalid);
+
+        // execution-apis#609: newPayloadV6 reports a censoring payload as VALID with
+        // inclusionListSatisfied=false rather than the legacy INCLUSION_LIST_UNSATISFIED status.
+        // Fixtures authored against the old status still expect it, so normalize for comparison.
+        string actualStatus = payloadStatus is PayloadStatusV2 { Status: PayloadStatus.Valid, InclusionListSatisfied: false }
+            ? PayloadStatus.InclusionListUnsatisfied
+            : payloadStatus.Status;
+        Assert.That(actualStatus, Is.EqualTo(expectedStatus), $"engine_newPayloadV{payloadVersion} returned {actualStatus}, expected {expectedStatus}. ValidationError: {payloadStatus.ValidationError}");
 
         if (expectedValidationError is not null)
             AssertValidationError(payloadStatus.ValidationError, expectedValidationError, payloadVersion);

src/Nethermind/Ethereum.Test.Base/TestEngineNewPayloadsJson.cs

@@ -11,6 +11,11 @@ public class TestEngineNewPayloadsJson
         public string? NewPayloadVersion { get; set; }
         public string? ForkChoiceUpdatedVersion { get; set; }
         public string? ValidationError { get; set; }
+        // EIP-7805: RLP-encoded txs, emitted by the fixture out-of-band from `params`;
+        // appended as the 5th positional arg when targeting newPayloadV6.
+        public string[]? InclusionListTransactions { get; set; }
+        // Expected PayloadStatusV1.Status; when absent, derived from ValidationError.
+        public string? Status { get; set; }
 
         public ExecutionWitnessJson? ExecutionWitness { get; set; }
         public bool? ExecutionWitnessMutated { get; set; }

src/Nethermind/Nethermind.BalRecorder/BalRecordingBlockValidator.cs

@@ -2,9 +2,11 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
 using System.Diagnostics.CodeAnalysis;
+using Nethermind.Consensus.Processing;
 using Nethermind.Consensus.Validators;
 using Nethermind.Core;
 using Nethermind.Crypto;
+using Nethermind.Evm.State;
 
 namespace Nethermind.BalRecorder;
 
@@ -28,6 +30,9 @@ public bool ValidateSuggestedBlock(Block block, BlockHeader parent, [NotNullWhen
     public bool ValidateBodyAgainstHeader(BlockHeader header, BlockBody toBeValidated, [NotNullWhen(false)] out string? error) =>
         inner.ValidateBodyAgainstHeader(header, toBeValidated, out error);
 
+    public bool ValidateInclusionList(Block processedBlock, Block suggestedBlock, IWorldState worldState, ProcessingOptions options) =>
+        inner.ValidateInclusionList(processedBlock, suggestedBlock, worldState, options);
+
     public bool ValidateProcessedBlock(Block processedBlock, TxReceipt[] receipts, Block suggestedBlock, [NotNullWhen(false)] out string? error)
     {
         if (balSwitch.Enabled && suggestedBlock.Header.BlockAccessListHash is null)

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

@@ -58,6 +58,10 @@ private class BranchProcessorMock : IBranchProcessor
 
             internal readonly HashSet<Hash256> Processed = [];
 
+            // Captures the block instance actually handed to the branch processor (post-recovery-queue
+            // resolution) so tests can assert transient side-channel data survived — see the IL case.
+            internal readonly ConcurrentDictionary<Hash256, Block> ProcessedBlockByHash = new();
+
             private readonly ConcurrentHashSet<Hash256> _allowedToFail = [];
 
             private readonly HashSet<Hash256> _rootProcessed = [];
@@ -99,6 +103,7 @@ public Block[] Process(BlockHeader? baseBlock, IReadOnlyList<Block> suggestedBlo
                 }
 
                 Processed.AddRange(suggestedBlocks.Select(x => x.Hash!));
+                foreach (Block suggested in suggestedBlocks) ProcessedBlockByHash[suggested.Hash!] = suggested;
 
                 _logger.Info($"Processing {suggestedBlocks.Last().ToString(Block.Format.Short)}");
                 int nextBlock = 0;
@@ -275,6 +280,16 @@ public ProcessingTestContext AndRecoveryQueueLimitHasBeenReached()
             return this;
         }
 
+        public ProcessingTestContext InclusionListPreservedFor(Block block)
+        {
+            Assert.That(_branchProcessor.ProcessedBlockByHash.TryGetValue(block.Hash!, out Block? processed), Is.True,
+                $"Block {block.ToString(Block.Format.Short)} was not processed");
+            Assert.That(processed!.InclusionListTransactions, Is.Not.Null,
+                "Inclusion list was dropped before validation (recovery-queue re-resolve stripped it)");
+            Assert.That(processed.InclusionListTransactions!, Has.Length.EqualTo(block.InclusionListTransactions!.Length));
+            return this;
+        }
+
         public AfterBlock Processed(Block block)
         {
             _headBefore = _blockTree.Head?.Hash;
@@ -778,6 +793,23 @@ public void Can_change_branch_on_invalid_block_when_invalid_branch_is_in_the_que
             .ProcessedSkipped(_block4D8).IsDeletedAsInvalid()
             .FullyProcessed(_blockB2D4).BecomesNewHead();
 
+    // review r3595551681: when the recovery-queue limit is reached the processor would replace an
+    // IL-bearing block with a hash-only BlockRef re-resolved from the DB, dropping the transient
+    // (non-RLP) inclusion list. The full block must be kept so ValidateInclusionList still sees the IL.
+    [Test, MaxTime(Timeout.MaxTestTime)]
+    public void Inclusion_list_survives_recovery_queue_backlog()
+    {
+        Transaction ilTx = Build.A.Transaction.SignedAndResolved(TestItem.PrivateKeyA).TestObject;
+        Block ilBlock = Build.A.Block.WithNumber(1).WithNonce(111).WithParent(_block0).WithDifficulty(2)
+            .WithInclusionListTransactions([ilTx]).TestObject;
+
+        When.ProcessingBlocks
+            .AndRecoveryQueueLimitHasBeenReached()
+            .FullyProcessed(_block0).BecomesGenesis()
+            .FullyProcessed(ilBlock).BecomesNewHead()
+            .InclusionListPreservedFor(ilBlock);
+    }
+
     [Test, MaxTime(Timeout.MaxTestTime)]
     [Ignore("Not implemented yet - scenario when from suggested blocks we can see that previously suggested will not be winning")]
     [Todo(Improve.Performance, "We can skip processing losing branches by implementing code to pass this test")]