Merge branch 'main' into feat/update-retry

Author: frisitano

crates/chain-orchestrator/src/error.rs

@@ -89,6 +89,9 @@ pub enum ChainOrchestratorError {
         /// The derived block number.
         derived_block_number: u64,
     },
+    /// An error occurred while handling rollup node primitives.
+    #[error("An error occurred while handling rollup node primitives: {0}")]
+    RollupNodePrimitiveError(rollup_node_primitives::RollupNodePrimitiveError),
 }
 
 impl CanRetry for ChainOrchestratorError {

crates/chain-orchestrator/src/lib.rs

@@ -4,12 +4,11 @@
 use alloy_eips::Encodable2718;
 use alloy_primitives::{b256, bytes::Bytes, keccak256, B256};
 use alloy_provider::Provider;
-use alloy_rpc_types_engine::ExecutionData;
+use alloy_rpc_types_engine::ExecutionPayloadV1;
 use futures::StreamExt;
 use reth_chainspec::EthChainSpec;
 use reth_network_api::{BlockDownloaderProvider, FullNetwork};
 use reth_network_p2p::FullBlockClient;
-use reth_scroll_engine_primitives::try_into_block;
 use reth_scroll_node::ScrollNetworkPrimitives;
 use reth_scroll_primitives::ScrollBlock;
 use reth_tasks::shutdown::Shutdown;
@@ -449,22 +448,19 @@ impl<
                         .engine
                         .get_payload(fcu.payload_id.expect("payload_id can not be None"))
                         .await?;
-                    let block: ScrollBlock = try_into_block(
-                        ExecutionData { payload: payload.into(), sidecar: Default::default() },
-                        self.config.chain_spec().clone(),
-                    )
-                    .expect("block must be valid");
 
-                    let result = self.engine.new_payload(&block).await?;
+                    let block_info: L2BlockInfoWithL1Messages = (&payload)
+                        .try_into()
+                        .map_err(ChainOrchestratorError::RollupNodePrimitiveError)?;
+                    let result = self.engine.new_payload(payload).await?;
                     if result.is_invalid() {
                         return Err(ChainOrchestratorError::InvalidBatch(
-                            (&block).into(),
+                            block_info.block_info,
                             batch_info,
                         ));
                     }
 
                     // Update the forkchoice state to the new head.
-                    let block_info: L2BlockInfoWithL1Messages = (&block).into();
                     self.engine
                         .update_fcs(
                             Some(block_info.block_info),
@@ -1017,7 +1013,8 @@ impl<
 
         // Validate the new blocks by sending them to the engine.
         for block in &chain {
-            let status = self.engine.new_payload(block).await?;
+            let payload = ExecutionPayloadV1::from_block_slow(block);
+            let status = self.engine.new_payload(payload).await?;
             tracing::debug!(target: "scroll::chain_orchestrator", block_number = block.number, block_hash = ?block.hash_slow(), ?status, "New payload status from engine");
 
             if status.is_invalid() {

crates/engine/src/engine.rs

@@ -2,7 +2,6 @@ use super::{EngineError, ForkchoiceState};
 use alloy_rpc_types_engine::{
     ExecutionPayloadV1, ForkchoiceUpdated, PayloadStatus, PayloadStatusEnum,
 };
-use reth_scroll_primitives::ScrollBlock;
 use rollup_node_primitives::BlockInfo;
 use scroll_alloy_provider::ScrollEngineApi;
 use std::sync::Arc;
@@ -100,9 +99,11 @@ where
     }
 
     /// Submit a new payload to the engine.
-    pub async fn new_payload(&self, block: &ScrollBlock) -> Result<PayloadStatus, EngineError> {
-        tracing::trace!(target: "scroll::engine", block_number = block.number, block_hash = ?block.hash_slow(), "Submitting new payload to engine");
-        let payload = ExecutionPayloadV1::from_block_slow(block);
+    pub async fn new_payload(
+        &self,
+        payload: ExecutionPayloadV1,
+    ) -> Result<PayloadStatus, EngineError> {
+        tracing::trace!(target: "scroll::engine", block_number = payload.block_number, block_hash = ?payload.block_hash, "Submitting new payload to engine");
         let result = self.client.new_payload_v1(payload).await?;
 
         match &result.status {

crates/node/src/args.rs

@@ -661,7 +661,7 @@ pub struct SequencerArgs {
         long = "sequencer.l1-inclusion-mode",
         id = "sequencer_l1_inclusion_mode",
         value_name = "MODE",
-        default_value = "finalized",
+        default_value = "finalized:2",
         help = "L1 message inclusion mode. Use 'finalized' for finalized messages only, or 'depth:{number}' for block depth confirmation (e.g. 'depth:10')"
     )]
     pub l1_message_inclusion_mode: L1MessageInclusionMode,

crates/primitives/src/block.rs

@@ -1,7 +1,8 @@
+use crate::RollupNodePrimitiveError;
 use alloy_consensus::Header;
 use alloy_eips::{BlockNumHash, Decodable2718};
 use alloy_primitives::{B256, U256};
-use alloy_rpc_types_engine::ExecutionPayload;
+use alloy_rpc_types_engine::{ExecutionPayload, ExecutionPayloadV1};
 use core::{
     cmp::Ordering,
     future::Future,
@@ -179,23 +180,28 @@ impl From<&ScrollBlock> for L2BlockInfoWithL1Messages {
     }
 }
 
-impl From<&ExecutionPayload> for L2BlockInfoWithL1Messages {
-    fn from(value: &ExecutionPayload) -> Self {
-        let block_number = value.block_number();
-        let block_hash = value.block_hash();
-        let l1_messages = value
-            .as_v1()
-            .transactions
-            .iter()
-            .filter_map(|raw| {
-                (raw.as_ref().first() == Some(&L1_MESSAGE_TRANSACTION_TYPE))
-                    .then(|| {
-                        let tx = ScrollTransactionSigned::decode_2718(&mut raw.as_ref()).ok()?;
-                        Some(*tx.tx_hash())
-                    })
-                    .flatten()
-            })
-            .collect();
-        Self { block_info: BlockInfo { number: block_number, hash: block_hash }, l1_messages }
+impl TryFrom<&ExecutionPayload> for L2BlockInfoWithL1Messages {
+    type Error = RollupNodePrimitiveError;
+
+    fn try_from(value: &ExecutionPayload) -> Result<Self, Self::Error> {
+        value.as_v1().try_into()
+    }
+}
+
+impl TryFrom<&ExecutionPayloadV1> for L2BlockInfoWithL1Messages {
+    type Error = RollupNodePrimitiveError;
+
+    fn try_from(value: &ExecutionPayloadV1) -> Result<Self, Self::Error> {
+        let block_number = value.block_number;
+        let block_hash = value.block_hash;
+
+        let mut l1_messages = Vec::new();
+        for tx in &value.transactions {
+            if tx.as_ref().first() == Some(&L1_MESSAGE_TRANSACTION_TYPE) {
+                let tx = ScrollTransactionSigned::decode_2718(&mut tx.as_ref())?;
+                l1_messages.push(*tx.tx_hash())
+            }
+        }
+        Ok(Self { block_info: BlockInfo { number: block_number, hash: block_hash }, l1_messages })
     }
 }

crates/primitives/src/error.rs

@@ -0,0 +1,22 @@
+/// Errors related to Scroll primitives.
+#[derive(Debug)]
+pub enum RollupNodePrimitiveError {
+    /// Error decoding an execution payload.
+    ExecutionPayloadDecodeError(alloy_eips::eip2718::Eip2718Error),
+}
+
+impl From<alloy_eips::eip2718::Eip2718Error> for RollupNodePrimitiveError {
+    fn from(err: alloy_eips::eip2718::Eip2718Error) -> Self {
+        Self::ExecutionPayloadDecodeError(err)
+    }
+}
+
+impl core::fmt::Display for RollupNodePrimitiveError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::ExecutionPayloadDecodeError(e) => {
+                write!(f, "execution payload decode error: {e}")
+            }
+        }
+    }
+}

crates/primitives/src/lib.rs

@@ -22,6 +22,9 @@ pub use bounded_vec::BoundedVec;
 mod chain;
 pub use chain::ChainImport;
 
+mod error;
+pub use error::RollupNodePrimitiveError;
+
 mod metadata;
 pub use metadata::Metadata;