refactor engine api call ordering

Author: frisitano

bin/bridge/src/import.rs

@@ -46,7 +46,7 @@ impl BridgeBlockImport {
             .and_then(|i| Signature::from_compact(&extra_data[i..]).ok())
         {
             let block = block.block.clone();
-            trace!(target: "scroll::bridge::import", peer_id = %peer_id, block = ?block, "Received new block from eth-wire protocol");
+            trace!(target: "scroll::bridge::import", peer_id = %peer_id, block = ?block.hash_slow(), "Received new block from eth-wire protocol");
 
             // We trigger a new block event to be sent to the rollup node's network manager. If this
             // results in an error it means the network manager has been dropped.

crates/engine/src/engine.rs

@@ -72,20 +72,17 @@ where
     pub async fn handle_execution_payload(
         &self,
         execution_payload: ExecutionPayload,
-        mut fcs: ForkchoiceState,
+        fcs: ForkchoiceState,
     ) -> Result<(PayloadStatusEnum, PayloadStatusEnum), EngineDriverError> {
         // Convert the payload to the V1 format.
         let execution_payload = execution_payload.into_v1();
 
-        // update the fork choice state with the new block hash.
-        fcs.head_block_hash = execution_payload.block_num_hash().hash;
+        // Invoke the FCU with the new state.
+        let fcu = self.forkchoice_updated(fcs, None).await?;
 
         // Issue the new payload to the EN.
         let payload_status = self.new_payload(execution_payload).await?;
 
-        // Invoke the FCU with the new state.
-        let fcu = self.forkchoice_updated(fcs, None).await?;
-
         // We should never have a case where the fork choice is syncing as we have already validated
         // the payload and provided it to the EN.
         debug_assert!(fcu.is_valid());

crates/engine/src/fcs.rs

@@ -69,4 +69,9 @@ impl ForkchoiceState {
             finalized_block_hash: self.finalized.hash,
         }
     }
+
+    /// Returns `true` if the fork choice state is the genesis state.
+    pub fn is_genesis(&self) -> bool {
+        self.unsafe_.number == 0
+    }
 }

crates/network/src/manager.rs

@@ -124,7 +124,7 @@ impl NetworkManager {
     fn on_scroll_wire_event(&mut self, event: ScrollWireEvent) -> Option<NetworkManagerEvent> {
         match event {
             ScrollWireEvent::NewBlock { peer_id, block, signature } => {
-                trace!(target: "scroll::network::manager", peer_id = ?peer_id, block = ?block, signature = ?signature, "Received new block");
+                trace!(target: "scroll::network::manager", peer_id = ?peer_id, block = ?block.hash_slow(), signature = ?signature, "Received new block");
                 Some(NetworkManagerEvent::NewBlock(NewBlockWithPeer { peer_id, block, signature }))
             }
             // Only `NewBlock` events are expected from the scroll-wire protocol.
@@ -191,8 +191,6 @@ impl Future for NetworkManager {
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
-        trace!(target: "scroll::network::manager", "Polling network manager");
-
         let this = self.get_mut();
 
         // We handle the messages from the network handle.

crates/node/src/lib.rs

@@ -131,6 +131,16 @@ where
             return;
         }
 
+        // If the forkchoice state is at genesis, update the forkchoice state with the parent of the
+        // block.
+        if self.forkchoice_state.is_genesis() {
+            let parent = block.parent_num_hash();
+            self.forkchoice_state.update_unsafe_block_info(BlockInfo {
+                number: parent.number,
+                hash: block.parent_hash,
+            });
+        }
+
         // Send the block to the engine to validate the correctness of the block.
         let fcs = self.get_alloy_fcs();
         let engine = self.engine.clone();

crates/scroll-wire/src/connection/mod.rs

@@ -81,7 +81,7 @@ impl Stream for ScrollWireConnection {
             match msg.payload {
                 ScrollMessagePayload::NewBlock(new_block) => {
                     // If the signature can be decoded then we send a new block event.
-                    trace!(target: "scroll::wire::connection", peer_id = %this.peer_id, block = ?new_block.block, "Received new block from peer");
+                    trace!(target: "scroll::wire::connection", peer_id = %this.peer_id, block = ?new_block.block.hash_slow(), "Received new block from peer");
                     if let Ok(signature) = Signature::from_compact(&new_block.signature[..]) {
                         this.events
                             .send(ScrollWireEvent::NewBlock {

crates/scroll-wire/src/manager.rs

@@ -77,7 +77,7 @@ impl Future for ScrollWireManager {
             match new_block {
                 Some(ScrollWireEvent::NewBlock { peer_id, block, signature }) => {
                     // We announce the block to the network.
-                    trace!("Received new block with signature [{signature:?}] from the network: {block:?} ");
+                    trace!(target: "scroll::wire::manager", "Received new block with signature [{signature:?}] from the network: {:?} ", block.hash_slow());
                     return Poll::Ready(ScrollWireEvent::NewBlock { peer_id, block, signature });
                 }
                 Some(ScrollWireEvent::ConnectionEstablished {