chore: introduce separate structure for Shasta slot info

Cargo.toml

@@ -12,7 +12,7 @@ resolver = "2"
 default-members = ["node"]
 
 [workspace.package]
-version = "1.23.30"
+version = "1.23.31"
 edition = "2024"
 repository = "https://github.com/NethermindEth/Catalyst"
 license = "MIT"

common/src/shared/l2_block_v2.rs

@@ -1,13 +1,20 @@
 use crate::shared::l2_tx_lists::PreBuiltTxList;
 use alloy::primitives::Address;
 
+#[derive(Debug, Clone)]
+pub struct L2BlockV2Draft {
+    pub prebuilt_tx_list: PreBuiltTxList,
+    pub timestamp_sec: u64,
+    pub gas_limit_without_anchor: u64,
+}
+
 #[derive(Debug, Clone)]
 pub struct L2BlockV2 {
     pub prebuilt_tx_list: PreBuiltTxList,
     pub timestamp_sec: u64,
     pub coinbase: Address,
     pub anchor_block_number: u64,
-    pub gas_limit: u64,
+    pub gas_limit_without_anchor: u64,
 }
 
 impl L2BlockV2 {
@@ -16,29 +23,29 @@ impl L2BlockV2 {
         timestamp_sec: u64,
         coinbase: Address,
         anchor_block_number: u64,
-        gas_limit: u64,
+        gas_limit_without_anchor: u64,
     ) -> Self {
         L2BlockV2 {
             prebuilt_tx_list: tx_list,
             timestamp_sec,
             coinbase,
             anchor_block_number,
-            gas_limit,
+            gas_limit_without_anchor,
         }
     }
 
     pub fn new_empty(
         timestamp_sec: u64,
         coinbase: Address,
         anchor_block_number: u64,
-        gas_limit: u64,
+        gas_limit_without_anchor: u64,
     ) -> Self {
         L2BlockV2 {
             prebuilt_tx_list: PreBuiltTxList::empty(),
             timestamp_sec,
             coinbase,
             anchor_block_number,
-            gas_limit,
+            gas_limit_without_anchor,
         }
     }
 }

common/src/shared/l2_slot_info.rs

@@ -1,12 +1,17 @@
 use alloy::primitives::B256;
 
+pub trait SlotData {
+    fn slot_timestamp(&self) -> u64;
+    fn parent_id(&self) -> u64;
+    fn parent_hash(&self) -> &B256;
+}
+
 pub struct L2SlotInfo {
     base_fee: u64,
     slot_timestamp: u64,
     parent_id: u64,
     parent_hash: B256,
     parent_gas_used: u32,
-    parent_gas_limit_without_anchor: u64,
     parent_timestamp: u64,
 }
 
@@ -17,7 +22,6 @@ impl L2SlotInfo {
         parent_id: u64,
         parent_hash: B256,
         parent_gas_used: u32,
-        parent_gas_limit_without_anchor: u64,
         parent_timestamp: u64,
     ) -> Self {
         Self {
@@ -26,7 +30,6 @@ impl L2SlotInfo {
             parent_id,
             parent_hash,
             parent_gas_used,
-            parent_gas_limit_without_anchor,
             parent_timestamp,
         }
     }
@@ -51,11 +54,21 @@ impl L2SlotInfo {
         self.parent_gas_used
     }
 
-    pub fn parent_gas_limit_without_anchor(&self) -> u64 {
-        self.parent_gas_limit_without_anchor
-    }
-
     pub fn parent_timestamp(&self) -> u64 {
         self.parent_timestamp
     }
 }
+
+impl SlotData for L2SlotInfo {
+    fn slot_timestamp(&self) -> u64 {
+        self.slot_timestamp
+    }
+
+    fn parent_id(&self) -> u64 {
+        self.parent_id
+    }
+
+    fn parent_hash(&self) -> &B256 {
+        &self.parent_hash
+    }
+}

common/src/shared/l2_slot_info_v2.rs

@@ -0,0 +1,76 @@
+use super::l2_slot_info::SlotData;
+use alloy::primitives::B256;
+
+pub struct L2SlotContext {
+    pub info: L2SlotInfoV2,
+    pub end_of_sequencing: bool,
+    pub allow_forced_inclusion: bool,
+}
+
+#[derive(Debug, Clone)]
+pub struct L2SlotInfoV2 {
+    base_fee: u64,
+    slot_timestamp: u64,
+    parent_id: u64,
+    parent_hash: B256,
+    parent_gas_limit_without_anchor: u64,
+    parent_timestamp: u64,
+}
+
+impl L2SlotInfoV2 {
+    pub fn new(
+        base_fee: u64,
+        slot_timestamp: u64,
+        parent_id: u64,
+        parent_hash: B256,
+        parent_gas_limit_without_anchor: u64,
+        parent_timestamp: u64,
+    ) -> Self {
+        Self {
+            base_fee,
+            slot_timestamp,
+            parent_id,
+            parent_hash,
+            parent_gas_limit_without_anchor,
+            parent_timestamp,
+        }
+    }
+
+    pub fn base_fee(&self) -> u64 {
+        self.base_fee
+    }
+
+    pub fn slot_timestamp(&self) -> u64 {
+        self.slot_timestamp
+    }
+
+    pub fn parent_id(&self) -> u64 {
+        self.parent_id
+    }
+
+    pub fn parent_hash(&self) -> &B256 {
+        &self.parent_hash
+    }
+
+    pub fn parent_gas_limit_without_anchor(&self) -> u64 {
+        self.parent_gas_limit_without_anchor
+    }
+
+    pub fn parent_timestamp(&self) -> u64 {
+        self.parent_timestamp
+    }
+}
+
+impl SlotData for L2SlotInfoV2 {
+    fn slot_timestamp(&self) -> u64 {
+        self.slot_timestamp
+    }
+
+    fn parent_id(&self) -> u64 {
+        self.parent_id
+    }
+
+    fn parent_hash(&self) -> &B256 {
+        &self.parent_hash
+    }
+}

common/src/shared/mod.rs

@@ -5,5 +5,6 @@ pub mod head_verifier;
 pub mod l2_block;
 pub mod l2_block_v2;
 pub mod l2_slot_info;
+pub mod l2_slot_info_v2;
 pub mod l2_tx_lists;
 pub mod transaction_monitor;

pacaya/src/l2/taiko.rs

@@ -163,8 +163,6 @@ impl Taiko {
         let parent_id = block_info.header.number();
         let parent_hash = block_info.header.hash;
         let parent_gas_used = block_info.header.gas_used();
-        // For Pacaya we do not use that value so we can set it to zero
-        let parent_gas_limit_without_anchor = 0;
         let parent_timestamp = block_info.header.timestamp();
         // Safe conversion with overflow check
         let parent_gas_used_u32 = u32::try_from(parent_gas_used).map_err(|_| {
@@ -196,7 +194,6 @@ impl Taiko {
             parent_id,
             parent_hash,
             parent_gas_used_u32,
-            parent_gas_limit_without_anchor,
             parent_timestamp,
         ))
     }

pacaya/src/node/operator/mod.rs

@@ -8,7 +8,7 @@ use common::{
     fork_info::ForkInfo,
     l1::slot_clock::{Clock, SlotClock},
     l2::taiko_driver::{StatusProvider, models::TaikoStatus},
-    shared::l2_slot_info::L2SlotInfo,
+    shared::l2_slot_info::SlotData,
     utils::{cancellation_token::CancellationToken, types::*},
 };
 pub use status::Status;
@@ -65,7 +65,7 @@ impl<T: PreconfOperator, U: Clock, V: StatusProvider> Operator<T, U, V> {
     }
 
     /// Get the current status of the operator based on the current L1 and L2 slots
-    pub async fn get_status(&mut self, l2_slot_info: &L2SlotInfo) -> Result<Status, Error> {
+    pub async fn get_status<S: SlotData>(&mut self, l2_slot_info: &S) -> Result<Status, Error> {
         if !self
             .execution_layer
             .is_preconf_router_specified_in_taiko_wrapper()
@@ -183,9 +183,9 @@ impl<T: PreconfOperator, U: Clock, V: StatusProvider> Operator<T, U, V> {
         }
     }
 
-    async fn is_driver_synced(
+    async fn is_driver_synced<S: SlotData>(
         &mut self,
-        l2_slot_info: &L2SlotInfo,
+        l2_slot_info: &S,
         driver_status: &TaikoStatus,
     ) -> Result<bool, Error> {
         let taiko_geth_synced_with_l1 = self.is_taiko_geth_synced_with_l1(l2_slot_info).await?;
@@ -209,12 +209,12 @@ impl<T: PreconfOperator, U: Clock, V: StatusProvider> Operator<T, U, V> {
         Ok(false)
     }
 
-    async fn is_preconfer(
+    async fn is_preconfer<S: SlotData>(
         &mut self,
         current_operator: bool,
         handover_window: bool,
         l1_slot: Slot,
-        l2_slot_info: &L2SlotInfo,
+        l2_slot_info: &S,
         driver_status: &TaikoStatus,
     ) -> Result<bool, Error> {
         if self
@@ -245,10 +245,10 @@ impl<T: PreconfOperator, U: Clock, V: StatusProvider> Operator<T, U, V> {
         }
     }
 
-    async fn is_handover_buffer(
+    async fn is_handover_buffer<S: SlotData>(
         &self,
         l1_slot: Slot,
-        l2_slot_info: &L2SlotInfo,
+        l2_slot_info: &S,
         driver_status: &TaikoStatus,
     ) -> Result<bool, Error> {
         if self.get_ms_from_handover_window_start(l1_slot)? <= self.handover_start_buffer_ms {
@@ -262,10 +262,10 @@ impl<T: PreconfOperator, U: Clock, V: StatusProvider> Operator<T, U, V> {
         Ok(false)
     }
 
-    fn end_of_sequencing_marker_received(
+    fn end_of_sequencing_marker_received<S: SlotData>(
         &self,
         driver_status: &TaikoStatus,
-        l2_slot_info: &L2SlotInfo,
+        l2_slot_info: &S,
     ) -> bool {
         *l2_slot_info.parent_hash() == driver_status.end_of_sequencing_block_hash
     }
@@ -299,10 +299,10 @@ impl<T: PreconfOperator, U: Clock, V: StatusProvider> Operator<T, U, V> {
         Ok(result)
     }
 
-    async fn is_block_height_synced_between_taiko_geth_and_the_driver(
+    async fn is_block_height_synced_between_taiko_geth_and_the_driver<S: SlotData>(
         &self,
         status: &TaikoStatus,
-        l2_slot_info: &L2SlotInfo,
+        l2_slot_info: &S,
     ) -> Result<bool, Error> {
         if status.highest_unsafe_l2_payload_block_id == 0 {
             return Ok(true);
@@ -319,7 +319,10 @@ impl<T: PreconfOperator, U: Clock, V: StatusProvider> Operator<T, U, V> {
         Ok(taiko_geth_height == status.highest_unsafe_l2_payload_block_id)
     }
 
-    async fn is_taiko_geth_synced_with_l1(&self, l2_slot_info: &L2SlotInfo) -> Result<bool, Error> {
+    async fn is_taiko_geth_synced_with_l1<S: SlotData>(
+        &self,
+        l2_slot_info: &S,
+    ) -> Result<bool, Error> {
         let taiko_inbox_height = self
             .execution_layer
             .get_l2_height_from_taiko_inbox()