L1: fix syncing header request on side-chain scenarios

[rodrigo-o]

Right now we are having 16 hive test failing in the engine-cancun suite, they are related to Syncing + reorg. The initial issue with these test is that they try to sync from the current head to the target header, which is in a completely different chain (a side-chain that forked ~5 blocks before), which ends in an interminable cycle of request to peers where we only recieve the current header (which appears to be the way that geth answers when it knows that there is no path between the from header and the target for syncing.

[rodrigo-o]

A quick-and-dirty workaround to look this working as expected is the following (implemented as part of this testing PR):

diff --git a/crates/networking/p2p/sync.rs b/crates/networking/p2p/sync.rs
index 47cb86e3f..54bc1d92e 100644
--- a/crates/networking/p2p/sync.rs
+++ b/crates/networking/p2p/sync.rs
@@ -178,7 +178,7 @@ impl SyncManager {
         };
 
         loop {
-            debug!("Requesting Block Headers from {current_head}");
+            debug!("Requesting Block Headers from {current_head} to {sync_head}");
             // Request Block Headers from Peer
             match self
                 .peers
@@ -186,6 +186,13 @@ impl SyncManager {
                 .await
             {
                 Some(mut block_headers) => {
+                    if block_headers.len() == 1 && block_headers[0].compute_block_hash() == current_head && current_head != sync_head {
+                        warn!("Already at the current head {}, and number {} but not yet synced, we are at a fork, going back one more ancestor", current_head, block_headers[0].number);
+                        store.unset_canonical_block(block_headers[0].number)?;
+                        current_head = block_headers[0].parent_hash;
+                        continue;
+                    }
+
                     debug!(
                         "Received {} block headers| Last Number: {}",
                         block_headers.len(),
@@ -293,6 +300,7 @@ impl SyncManager {
                 self.sync_mode = SyncMode::Full;
             }
             SyncMode::Full => {
+                info!("Starting full sync of headers");
                 // full-sync: Fetch all block bodies and execute them sequentially to build the state
                 download_and_run_blocks(
                     all_block_hashes,
@@ -328,12 +336,17 @@ async fn download_and_run_blocks(
                 .drain(..block_bodies_len)
                 .zip(block_bodies.into_iter())
             {
+                info!("Processing block {}", hash);
                 let header = store
                     .get_block_header_by_hash(hash)?
                     .ok_or(SyncError::CorruptDB)?;
                 let number = header.number;
                 let block = Block::new(header, body);
                 if let Err(error) = blockchain.add_block(&block) {
+                    warn!(
+                        "Failed to execute block {} with hash {}: {}",
+                        number, hash, error
+                    );
                     invalid_ancestors.insert(hash, last_valid_hash);
                     return Err(error.into());
                 }
@@ -344,8 +357,17 @@ async fn download_and_run_blocks(
             info!("Executed & stored {} blocks", block_bodies_len);
             // Check if we need to ask for another batch
             if block_hashes.is_empty() {
+                info!("block_hashes is empty, breaking");
                 break;
             }
+        } else {
+            if block_hashes.is_empty() {
+                warn!("No hashes to fetch, aborting sync");
+            } else {
+                warn!("Failed to fetch block bodies, aborting sync");
+            }
+
+            return Ok(());
         }
     }
     Ok(())

In this case we now go 1 step backwards every time we detect the current sync request returned just the head (signaling we should be in a sidechain). This is not a proper solution, we need to investigate an alternative and implement a proper way to find the common ancestor detecting when we are trying to sync from a side-chain.