feat(l1): download all headers from new to old as first step of full sync

crates/blockchain/fork_choice.rs

@@ -3,6 +3,7 @@ use ethrex_common::{
     types::{BlockHash, BlockHeader, BlockNumber},
 };
 use ethrex_storage::{Store, error::StoreError};
+use tracing::info;
 
 use crate::{
     error::{self, InvalidForkChoice},
@@ -24,6 +25,9 @@ pub async fn apply_fork_choice(
     safe_hash: H256,
     finalized_hash: H256,
 ) -> Result<BlockHeader, InvalidForkChoice> {
+    info!(
+        "Applying fork choice: head: {head_hash}, safe: {safe_hash}, finalized: {finalized_hash}"
+    );
     if head_hash.is_zero() {
         return Err(InvalidForkChoice::InvalidHeadHash);
     }
@@ -42,6 +46,13 @@ pub async fn apply_fork_choice(
 
     let head_res = store.get_block_header_by_hash(head_hash)?;
 
+    info!(
+        "Applying fork choice: head: {head_hash}:{:?}, safe: {safe_hash}:{:?}, finalized: {finalized_hash}:{:?}",
+        head_res.as_ref().map(|h| h.number),
+        safe_res.as_ref().map(|h| h.number),
+        finalized_res.as_ref().map(|h| h.number),
+    );
+
     if !safe_hash.is_zero() {
         check_order(&safe_res, &head_res)?;
     }

crates/blockchain/vm.rs

@@ -7,7 +7,7 @@ use ethrex_common::{
 use ethrex_storage::Store;
 use ethrex_vm::{EvmError, VmDatabase};
 use std::{cmp::Ordering, collections::HashMap};
-use tracing::instrument;
+use tracing::{info, instrument};
 
 #[derive(Clone)]
 pub struct StoreVmDatabase {
@@ -77,7 +77,19 @@ impl VmDatabase for StoreVmDatabase {
             }
         // If our block is not canonical then we must look for the target in our block's ancestors
         } else {
-            for ancestor_res in self.store.ancestors(self.block_hash) {
+            let lookup_hash = if self.block_hash_cache.is_empty() {
+                self.block_hash
+            } else {
+                info!(
+                    "[EDGE_CASE]: block hash not in cache but have cache, using oldest block hash for ancestor lookup"
+                );
+                self.block_hash_cache
+                    .iter()
+                    .min_by_key(|(n, _)| **n).map(|(_, h)| *h)
+                    .unwrap_or(self.block_hash)
+            };
+            // Edge case: we might have some of this block's ancestors cached and some stored, search for furtherst ancestor on the cache befor elooking up stored ancestors
+            for ancestor_res in self.store.ancestors(lookup_hash) {
                 let (hash, ancestor) = ancestor_res.map_err(|e| EvmError::DB(e.to_string()))?;
                 match ancestor.number.cmp(&block_number) {
                     Ordering::Greater => continue,

crates/networking/p2p/peer_handler.rs

@@ -19,7 +19,7 @@ use crate::{
         },
     },
     snap::encodable_to_proof,
-    sync::{AccountStorageRoots, BlockSyncState, block_is_stale, update_pivot},
+    sync::{AccountStorageRoots, SnapBlockSyncState, block_is_stale, update_pivot},
     utils::{
         AccountsWithStorage, dump_accounts_to_file, dump_storages_to_file,
         get_account_state_snapshot_file, get_account_storages_snapshot_file,
@@ -679,7 +679,7 @@ impl PeerHandler {
         limit: H256,
         account_state_snapshots_dir: &Path,
         pivot_header: &mut BlockHeader,
-        block_sync_state: &mut BlockSyncState,
+        block_sync_state: &mut SnapBlockSyncState,
     ) -> Result<(), PeerHandlerError> {
         METRICS
             .current_step