Merge pull request #198 from decipherhub/fix/parent-hash-bug

fix: restore last_block_hash on node restart

Author: qj0r9j0vc2

crates/node/src/execution_bridge.rs

@@ -279,6 +279,39 @@ impl ExecutionBridge {
         }
     }
 
+    /// Restore the last block hash from storage on node restart.
+    ///
+    /// This MUST be called after node restart when blocks already exist in storage.
+    /// It ensures that the next block's parent_hash correctly references the latest
+    /// stored block's hash, maintaining proper chain connectivity.
+    ///
+    /// # Arguments
+    ///
+    /// * `latest_block_hash` - The hash of the latest block in storage
+    ///
+    /// # Note
+    ///
+    /// This method should be called AFTER `set_genesis_block_hash` during node
+    /// initialization. If there are blocks beyond genesis in storage, this method
+    /// should be called to update `last_block_hash` to the latest block's hash.
+    pub fn restore_last_block_hash(&self, latest_block_hash: B256) {
+        match self.last_block_hash.write() {
+            Ok(mut guard) => {
+                *guard = latest_block_hash;
+                info!(
+                    latest_block_hash = %latest_block_hash,
+                    "Execution bridge restored last block hash from storage (node restart recovery)"
+                );
+            }
+            Err(e) => {
+                warn!(
+                    error = %e,
+                    "Failed to restore last block hash - lock poisoned, next block may have incorrect parent_hash"
+                );
+            }
+        }
+    }
+
     /// Validate a transaction for mempool CheckTx
     ///
     /// This is called by workers before accepting transactions into batches.
@@ -830,4 +863,47 @@ mod tests {
 
         assert_eq!(bridge.gas_limit(), 50_000_000);
     }
+
+    #[tokio::test]
+    async fn test_restore_last_block_hash() {
+        let (bridge, _temp_dir) = create_default_bridge().unwrap();
+
+        // Initially should be B256::ZERO
+        let initial_hash = bridge.last_block_hash.read().map(|guard| *guard).unwrap();
+        assert_eq!(initial_hash, B256::ZERO);
+
+        // Restore to a specific block hash (simulating node restart recovery)
+        let latest_block_hash = B256::from([0xABu8; 32]);
+        bridge.restore_last_block_hash(latest_block_hash);
+
+        // Should now be updated to the restored hash
+        let restored_hash = bridge.last_block_hash.read().map(|guard| *guard).unwrap();
+        assert_eq!(
+            restored_hash, latest_block_hash,
+            "restore_last_block_hash should update last_block_hash to the latest block's hash"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_restore_overrides_genesis_hash() {
+        let (bridge, _temp_dir) = create_default_bridge().unwrap();
+
+        // First set genesis hash (simulating initial node startup)
+        let genesis_hash = B256::from([0x01u8; 32]);
+        bridge.set_genesis_block_hash(genesis_hash);
+
+        let after_genesis = bridge.last_block_hash.read().map(|guard| *guard).unwrap();
+        assert_eq!(after_genesis, genesis_hash);
+
+        // Now restore to latest block hash (simulating node restart with existing blocks)
+        let latest_block_hash = B256::from([0xFFu8; 32]);
+        bridge.restore_last_block_hash(latest_block_hash);
+
+        // Should be updated to the latest, not genesis
+        let after_restore = bridge.last_block_hash.read().map(|guard| *guard).unwrap();
+        assert_eq!(
+            after_restore, latest_block_hash,
+            "restore_last_block_hash should override any previously set hash"
+        );
+    }
 }

crates/node/src/node.rs

@@ -1176,6 +1176,32 @@ impl Node {
             if let Ok(Some(latest)) = storage.block_store().get_latest_block_number().await {
                 storage.set_latest_block(latest);
                 info!("Initialized RPC latest_block from storage: {}", latest);
+
+                // CRITICAL: Restore last_block_hash for correct parent_hash in next block
+                // On node restart, the ExecutionBridge's in-memory last_block_hash is lost.
+                // We must restore it from the latest block in storage to ensure the next
+                // block's parent_hash correctly references the latest block's hash.
+                if latest > 0 {
+                    if let Some(ref bridge) = self.execution_bridge {
+                        match storage.block_store().get_block_by_number(latest).await {
+                            Ok(Some(latest_block)) => {
+                                bridge.restore_last_block_hash(B256::from(latest_block.hash));
+                            }
+                            Ok(None) => {
+                                warn!(
+                                    "Latest block {} not found in storage despite get_latest_block_number returning it",
+                                    latest
+                                );
+                            }
+                            Err(e) => {
+                                warn!(
+                                    "Failed to retrieve latest block {} for hash recovery: {}",
+                                    latest, e
+                                );
+                            }
+                        }
+                    }
+                }
             }
 
             Some(storage)