hotfix: blockchain/backend: Skip genesis leaf to unblock syncing

substrate/primitives/blockchain/src/backend.rs

@@ -255,10 +255,11 @@ pub trait Backend<Block: BlockT>:
 	) -> std::result::Result<DisplacedLeavesAfterFinalization<Block>, Error> {
 		let leaves = self.leaves()?;
 
+		let now = std::time::Instant::now();
 		debug!(
 			target: crate::LOG_TARGET,
 			?leaves,
-			%finalized_block_hash,
+			?finalized_block_hash,
 			?finalized_block_number,
 			"Checking for displaced leaves after finalization."
 		);
@@ -281,7 +282,15 @@ pub trait Backend<Block: BlockT>:
 				);
 				return Ok(DisplacedLeavesAfterFinalization::default());
 			},
-			Err(e) => Err(e)?,
+			Err(e) => {
+				debug!(
+					target: crate::LOG_TARGET,
+					hash = ?finalized_block_hash,
+					err = ?e,
+					"Failed to fetch block"
+				);
+				return Err(e);
+			},
 		};
 		finalized_chain.push_front(MinimalBlockMetadata::from(&current_finalized));
 
@@ -297,10 +306,34 @@ pub trait Backend<Block: BlockT>:
 		let mut displaced_blocks_candidates = Vec::new();
 
 		for leaf_hash in leaves {
+			let info = self.info();
+			if leaf_hash == info.genesis_hash {
+				// Genesis block is not displaced
+				debug!(
+					target: crate::LOG_TARGET,
+					"Skip genesis block {leaf_hash:?} reporterd as leaf (elapsed {:?})", now.elapsed(),
+				);
+
+				continue;
+			}
+
 			let mut current_header_metadata =
-				MinimalBlockMetadata::from(&self.header_metadata(leaf_hash)?);
+				MinimalBlockMetadata::from(&self.header_metadata(leaf_hash).map_err(|err| {
+					debug!(
+						target: crate::LOG_TARGET,
+						?err,
+						"Failed to fetch header for {leaf_hash:?} (elapsed {:?})", now.elapsed(),
+					);
+					err
+				})?);
 			let leaf_number = current_header_metadata.number;
 
+			debug!(
+				target: crate::LOG_TARGET,
+				?leaf_number,
+				"Handle displaced leaf {leaf_hash:?} (elapsed {:?})", now.elapsed(),
+			);
+
 			// Collect all block hashes until the height of the finalized block
 			displaced_blocks_candidates.clear();
 			while current_header_metadata.number > finalized_block_number {
@@ -313,7 +346,15 @@ pub trait Backend<Block: BlockT>:
 					},
 					None => {
 						current_header_metadata =
-							MinimalBlockMetadata::from(&self.header_metadata(parent_hash)?);
+							MinimalBlockMetadata::from(&self.header_metadata(parent_hash).map_err(|err| {
+								debug!(
+									target: crate::LOG_TARGET,
+									?err,
+									"Failed to fetch header for parent hash {parent_hash:?} during leaf tracking (elapsed {:?})", now.elapsed(),
+								);
+
+								err
+							})?);
 						// Cache locally in case more branches above finalized block reference
 						// the same block hash
 						local_cache.insert(parent_hash, current_header_metadata);
@@ -324,6 +365,11 @@ pub trait Backend<Block: BlockT>:
 			// If points back to the finalized header then nothing left to do, this leaf will be
 			// checked again later
 			if current_header_metadata.hash == finalized_block_hash {
+				debug!(
+					target: crate::LOG_TARGET,
+					"Leaf points to the finalized header {leaf_hash:?}, skipping for now (elapsed {:?})", now.elapsed(),
+				);
+
 				continue;
 			}
 
@@ -332,6 +378,14 @@ pub trait Backend<Block: BlockT>:
 			// check for this gap later.
 			displaced_blocks_candidates.push(current_header_metadata.hash);
 
+			debug!(
+				target: crate::LOG_TARGET,
+				current_hash = ?current_header_metadata.hash,
+				current_num = ?current_header_metadata.number,
+				?finalized_block_number,
+				"Looking for path from finalized block number to current leaf number"
+			);
+
 			// Collect the rest of the displaced blocks of leaf branch
 			for distance_from_finalized in 1_u32.. {
 				// Find block at `distance_from_finalized` from finalized block
@@ -352,7 +406,14 @@ pub trait Backend<Block: BlockT>:
 									);
 									break;
 								},
-								Err(e) => Err(e)?,
+								Err(e) => {
+									debug!(
+										target: crate::LOG_TARGET,
+										err = ?e,
+										"Failed to fetch header for parent hash {:?} during block collection (elapsed {:?})", to_fetch.parent, now.elapsed(),
+									);
+									return Err(e);
+								},
 							};
 							let metadata = MinimalBlockMetadata::from(&metadata);
 							let result = (metadata.number, metadata.hash);
@@ -372,20 +433,44 @@ pub trait Backend<Block: BlockT>:
 					// Reached finalized chain, nothing left to do
 					result.displaced_blocks.extend(displaced_blocks_candidates.drain(..));
 					result.displaced_leaves.push((leaf_number, leaf_hash));
+
+					debug!(
+						target: crate::LOG_TARGET,
+						"Found displaced leaf {leaf_hash:?} (elapsed {:?})", now.elapsed(),
+					);
 					break;
 				}
 
 				// Store displaced block and look deeper for block on finalized chain
+				debug!(
+					target: crate::LOG_TARGET,
+					"Found displaced block {parent_hash:?} and look further... (elapsed {:?})", now.elapsed(),
+				);
 				displaced_blocks_candidates.push(parent_hash);
 				current_header_metadata =
-					MinimalBlockMetadata::from(&self.header_metadata(parent_hash)?);
+					MinimalBlockMetadata::from(&self.header_metadata(parent_hash).map_err(|err| {
+						debug!(
+							target: crate::LOG_TARGET,
+							?err,
+							"Failed to fetch header for parent {parent_hash:?} during displaced block collection (elapsed {:?})", now.elapsed(),
+						);
+						err
+					})?);
 			}
 		}
 
 		// There could be duplicates shared by multiple branches, clean them up
 		result.displaced_blocks.sort_unstable();
 		result.displaced_blocks.dedup();
 
+		debug!(
+			target: crate::LOG_TARGET,
+			%finalized_block_hash,
+			?finalized_block_number,
+			"Finished with result {result:?} (elapsed {:?})",
+			now.elapsed(),
+		);
+
 		return Ok(result);
 	}
 }