Fix wrong parent block due to reorg (#8159)

Co-authored-by: Szymon Kulec <[email protected]>

Author: 2 people

src/Nethermind/Nethermind.Core/ChainLevelInfo.cs

@@ -17,6 +17,8 @@ public ChainLevelInfo(bool hasBlockInMainChain, params BlockInfo[] blockInfos)
             BlockInfos = blockInfos;
         }
 
+        private const int NotFound = -1;
+
         public bool HasNonBeaconBlocks => BlockInfos.Any(static b => (b.Metadata & (BlockMetadata.BeaconHeader | BlockMetadata.BeaconBody)) == 0);
         public bool HasBeaconBlocks => BlockInfos.Any(static b => (b.Metadata & (BlockMetadata.BeaconHeader | BlockMetadata.BeaconBody)) != 0);
         public bool HasBlockOnMainChain { get; set; }
@@ -72,6 +74,21 @@ public BlockInfo? BeaconMainChainBlock
             return null;
         }
 
+        private bool TryFindBeaconMainChainIndex(out int index)
+        {
+            for (int i = 0; i < BlockInfos.Length; i++)
+            {
+                if (BlockInfos[i].IsBeaconMainChain)
+                {
+                    index = i;
+                    return true;
+                }
+            }
+
+            index = NotFound;
+            return false;
+        }
+
         public BlockInfo? FindBlockInfo(Hash256 blockHash)
         {
             int? index = FindIndex(blockHash);
@@ -103,6 +120,12 @@ public void InsertBlockInfo(Hash256 hash, BlockInfo blockInfo, bool setAsMain)
                 blockInfos[index] = blockInfos[0];
                 blockInfos[0] = blockInfo;
             }
+            // prioritise new beacon info from beacon sync over old fcu
+            else if (blockInfo.IsBeaconMainChain && TryFindBeaconMainChainIndex(out int beaconMainChainIndex))
+            {
+                blockInfos[index] = blockInfos[beaconMainChainIndex];
+                blockInfos[beaconMainChainIndex] = blockInfo;
+            }
             else
             {
                 blockInfos[index] = blockInfo;

src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.V3.cs

@@ -9,11 +9,14 @@
 using System.Threading;
 using System.Threading.Tasks;
 using FluentAssertions;
+using Nethermind.Blockchain;
+using Nethermind.Blockchain.Synchronization;
 using Nethermind.Consensus.Producers;
 using Nethermind.Core;
 using Nethermind.Core.Crypto;
 using Nethermind.Core.Extensions;
 using Nethermind.Core.Specs;
+using Nethermind.Core.Test;
 using Nethermind.Core.Test.Builders;
 using Nethermind.Crypto;
 using Nethermind.Evm;
@@ -24,9 +27,13 @@
 using Nethermind.Merge.Plugin.Data;
 using Nethermind.Merge.Plugin.GC;
 using Nethermind.Merge.Plugin.Handlers;
+using Nethermind.Merge.Plugin.Synchronization;
 using Nethermind.Serialization.Json;
 using Nethermind.Serialization.Rlp;
 using Nethermind.Specs.Forks;
+using Nethermind.Stats;
+using Nethermind.Synchronization.Peers;
+using Nethermind.Synchronization.Peers.AllocationStrategies;
 using Nethermind.TxPool;
 using NSubstitute;
 using NUnit.Framework;
@@ -656,6 +663,60 @@ public async Task GetBlobsV1_should_return_mix_of_blobs_and_nulls([Values(1, 2,
         }
     }
 
+    [Test]
+    public async Task Sync_proper_chain_when_header_fork_came_from_fcu_and_beacon_sync()
+    {
+        // fork A
+        MergeTestBlockchain chainA = await CreateBlockchain(releaseSpec: Cancun.Instance);
+        IEngineRpcModule rpcModuleA = CreateEngineModule(chainA, null, TimeSpan.FromDays(1));
+        await rpcModuleA.engine_forkchoiceUpdatedV3(new(chainA.BlockTree.Head!.Hash!, chainA.BlockTree.Head!.Hash!, chainA.BlockTree.Head!.Hash!), null);
+
+        // main fork B
+        MergeTestBlockchain chainB = await CreateBlockchain(releaseSpec: Cancun.Instance);
+        IEngineRpcModule rpcModuleB = CreateEngineModule(chainB, null, TimeSpan.FromDays(1));
+        await rpcModuleB.engine_forkchoiceUpdatedV3(new(chainA.BlockTree.Head!.Hash!, chainA.BlockTree.Head!.Hash!, chainA.BlockTree.Head!.Hash!), null);
+
+        // syncing chain
+        MergeTestBlockchain chainC = await CreateBlockchain(releaseSpec: Cancun.Instance);
+        IEngineRpcModule rpcModuleC = CreateEngineModule(chainC, null, TimeSpan.FromDays(1));
+        await rpcModuleC.engine_forkchoiceUpdatedV3(new(chainA.BlockTree.Head!.Hash!, chainA.BlockTree.Head!.Hash!, chainA.BlockTree.Head!.Hash!), null);
+
+        ExecutionPayloadV3 payloadResultA1 = await AddNewBlockV3(rpcModuleA, chainA, 1);
+        ExecutionPayloadV3 payloadResultA2 = await AddNewBlockV3(rpcModuleA, chainA, 1);
+
+        ExecutionPayloadV3 payloadResultB1 = await AddNewBlockV3(rpcModuleB, chainB, 1);
+        // fork
+        ExecutionPayloadV3 payloadResultB2 = await AddNewBlockV3(rpcModuleB, chainB, 2);
+        ExecutionPayloadV3 payloadResultB3 = await AddNewBlockV3(rpcModuleB, chainB, 1);
+
+        SyncPeerMock chainAPeer = new SyncPeerMock(chainA.BlockTree);
+        SyncPeerAllocation alloc = new SyncPeerAllocation(new PeerInfo(chainAPeer), AllocationContexts.All);
+        alloc.AllocateBestPeer(new[] { new PeerInfo(chainAPeer) }, Substitute.For<INodeStatsManager>(), Substitute.For<IBlockTree>());
+        chainC.SyncPeerPool!.Allocate(
+            Arg.Any<IPeerAllocationStrategy>(),
+            Arg.Any<AllocationContexts>(),
+            Arg.Any<int>(),
+            Arg.Any<CancellationToken>())!.Returns(Task.FromResult(alloc));
+
+
+        await rpcModuleC.engine_forkchoiceUpdatedV3(new(payloadResultA1.BlockHash, chainC.BlockTree.GenesisHash, chainC.BlockTree.GenesisHash), null);
+        await rpcModuleC.engine_forkchoiceUpdatedV3(new(payloadResultA2.BlockHash, chainC.BlockTree.GenesisHash, chainC.BlockTree.GenesisHash), null);
+        await Task.Delay(1000);
+
+        await rpcModuleC.engine_newPayloadV3(payloadResultB2, [], TestItem.KeccakE);
+        await rpcModuleC.engine_newPayloadV3(payloadResultB3, [], TestItem.KeccakE);
+
+        await Task.Delay(1000);
+        AddBlockResult res = chainC.BlockTree.Insert(chainB.BlockTree.FindBlock(2)!.Header, BlockTreeInsertHeaderOptions.BeaconHeaderInsert);
+        await rpcModuleC.engine_forkchoiceUpdatedV3(new(payloadResultB3.BlockHash, chainC.BlockTree.GenesisHash, chainC.BlockTree.GenesisHash), null);
+
+        BlockHeader[]? heads = new ChainLevelHelper(chainC.BlockTree, chainC.BeaconPivot!, new SyncConfig(), chainC.LogManager)
+            .GetNextHeaders(10, 3);
+
+        Assert.That(heads?[2].Hash, Is.EqualTo(payloadResultB2.BlockHash));
+        Assert.That(heads?[3].Hash, Is.EqualTo(payloadResultB3.BlockHash));
+    }
+
     public static IEnumerable<TestCaseData> ForkchoiceUpdatedV3DeclinedTestCaseSource
     {
         get
@@ -808,7 +869,7 @@ public static IEnumerable<TestCaseData> CancunFieldsTestSource
         }
     }
 
-    private async Task AddNewBlockV3(IEngineRpcModule rpcModule, MergeTestBlockchain chain, int transactionCount = 0)
+    private async Task<ExecutionPayloadV3> AddNewBlockV3(IEngineRpcModule rpcModule, MergeTestBlockchain chain, int transactionCount = 0)
     {
         Transaction[] txs = BuildTransactions(chain, chain.BlockTree.Head!.Hash!, TestItem.PrivateKeyA, TestItem.AddressB, (uint)transactionCount, 0, out _, out _, 0);
         chain.AddTransactions(txs);
@@ -842,6 +903,8 @@ private async Task AddNewBlockV3(IEngineRpcModule rpcModule, MergeTestBlockchain
 
         ForkchoiceStateV1 newForkchoiceState = new(payload.ExecutionPayload.BlockHash, payload.ExecutionPayload.BlockHash, payload.ExecutionPayload.BlockHash);
         await rpcModule.engine_forkchoiceUpdatedV3(newForkchoiceState, null);
+
+        return payload.ExecutionPayload;
     }
 
     private async Task<(IEngineRpcModule, string?, Transaction[], MergeTestBlockchain chain)> BuildAndGetPayloadV3Result(

src/Nethermind/Nethermind.Serialization.Rlp/HeaderDecoder.cs

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
 using System;
-using System.Threading;
 using Nethermind.Core;
 using Nethermind.Core.Crypto;
 using Nethermind.Int256;