refactor(protocol/protocol) switch to nested structs

Author: einar-oplabs

crates/protocol/derive/src/stages/batch/batch_queue.rs

@@ -987,16 +987,16 @@ mod tests {
             batch_vec.push(Ok(batch));
         }
         // Insert a deposit transaction in the front of the second batch txs
-        let expected = L1BlockInfoBedrock {
-            number: 16988980031808077784,
-            time: 1697121143,
-            base_fee: 10419034451,
-            block_hash: b256!("392012032675be9f94aae5ab442de73c5f4fb1bf30fa7dd0d2442239899a40fc"),
-            sequence_number: 4,
-            batcher_address: address!("6887246668a3b87f54deb3b94ba47a6f63f32985"),
-            l1_fee_overhead: U256::from(0xbc),
-            l1_fee_scalar: U256::from(0xa6fe0),
-        };
+        let expected = L1BlockInfoBedrock::new(
+            16988980031808077784,
+            1697121143,
+            10419034451,
+            b256!("392012032675be9f94aae5ab442de73c5f4fb1bf30fa7dd0d2442239899a40fc"),
+            4,
+            address!("6887246668a3b87f54deb3b94ba47a6f63f32985"),
+            U256::from(0xbc),
+            U256::from(0xa6fe0),
+        );
         let deposit_tx_calldata: Bytes = L1BlockInfoTx::Bedrock(expected).encode_calldata();
         let tx = TxDeposit {
             source_hash: B256::left_padding_from(&[0xde, 0xad]),

crates/protocol/protocol/src/info/basefield.rs

@@ -0,0 +1,4 @@
+/// For structs that has an embedded basefield.
+pub(crate) trait HasBaseField<BaseField> {
+    fn base(&self) -> BaseField;
+}

crates/protocol/protocol/src/info/bedrock.rs

@@ -3,8 +3,10 @@
 use alloc::vec::Vec;
 use alloy_primitives::{Address, B256, Bytes, U256};
 
-use crate::DecodeError;
-
+use crate::{
+    DecodeError,
+    info::{HasBaseField, L1BlockInfoBedrockBaseFields, bedrock_base::L1BlockInfoBedrockBase},
+};
 /// Represents the fields within a Bedrock L1 block info transaction.
 ///
 /// Bedrock Binary Format
@@ -24,24 +26,73 @@ use crate::DecodeError;
 #[derive(Debug, Clone, Hash, Eq, PartialEq, Default, Copy)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct L1BlockInfoBedrock {
-    /// The current L1 origin block number
-    pub number: u64,
-    /// The current L1 origin block's timestamp
-    pub time: u64,
-    /// The current L1 origin block's basefee
-    pub base_fee: u64,
-    /// The current L1 origin block's hash
-    pub block_hash: B256,
-    /// The current sequence number
-    pub sequence_number: u64,
-    /// The address of the batch submitter
-    pub batcher_address: Address,
-    /// The fee overhead for L1 data
+    #[cfg_attr(feature = "serde", serde(flatten))]
+    base: L1BlockInfoBedrockBase,
+    /// The fee overhead for L1 data. Deprecated in Ecotone.
     pub l1_fee_overhead: U256,
-    /// The fee scalar for L1 data
+    /// The fee scalar for L1 data. Deprecated in Ecotone.
     pub l1_fee_scalar: U256,
 }
 
+impl HasBaseField<L1BlockInfoBedrockBase> for L1BlockInfoBedrock {
+    fn base(&self) -> L1BlockInfoBedrockBase {
+        self.base
+    }
+}
+
+impl L1BlockInfoBedrockBaseFields for L1BlockInfoBedrock {
+    fn number(&self) -> u64 {
+        self.base().number()
+    }
+
+    fn time(&self) -> u64 {
+        self.base().time()
+    }
+
+    fn base_fee(&self) -> u64 {
+        self.base().base_fee()
+    }
+
+    fn block_hash(&self) -> B256 {
+        self.base().block_hash()
+    }
+
+    fn sequence_number(&self) -> u64 {
+        self.base().sequence_number()
+    }
+
+    fn batcher_address(&self) -> Address {
+        self.base().batcher_address()
+    }
+}
+
+/// Accessors for fields deprecated after Bedrock.
+pub trait L1BlockInfoBedrockOnlyFields {
+    /// The fee overhead for L1 data. Deprecated in Ecotone.
+    fn l1_fee_overhead(&self) -> U256;
+
+    /// The fee scalar for L1 data. Deprecated in Ecotone.
+    fn l1_fee_scalar(&self) -> U256;
+}
+
+impl L1BlockInfoBedrockOnlyFields for L1BlockInfoBedrock {
+    fn l1_fee_overhead(&self) -> U256 {
+        self.l1_fee_overhead
+    }
+
+    fn l1_fee_scalar(&self) -> U256 {
+        self.l1_fee_scalar
+    }
+}
+
+/// Accessors trait for all fields on [`L1BlockInfoBedrock`].
+pub trait L1BlockInfoBedrockFields:
+    L1BlockInfoBedrockBaseFields + L1BlockInfoBedrockOnlyFields
+{
+}
+
+impl L1BlockInfoBedrockFields for L1BlockInfoBedrock {}
+
 impl L1BlockInfoBedrock {
     /// The length of an L1 info transaction in Bedrock.
     pub const L1_INFO_TX_LEN: usize = 4 + 32 * 8;
@@ -54,14 +105,14 @@ impl L1BlockInfoBedrock {
     pub fn encode_calldata(&self) -> Bytes {
         let mut buf = Vec::with_capacity(Self::L1_INFO_TX_LEN);
         buf.extend_from_slice(Self::L1_INFO_TX_SELECTOR.as_ref());
-        buf.extend_from_slice(U256::from(self.number).to_be_bytes::<32>().as_slice());
-        buf.extend_from_slice(U256::from(self.time).to_be_bytes::<32>().as_slice());
-        buf.extend_from_slice(U256::from(self.base_fee).to_be_bytes::<32>().as_slice());
-        buf.extend_from_slice(self.block_hash.as_slice());
-        buf.extend_from_slice(U256::from(self.sequence_number).to_be_bytes::<32>().as_slice());
-        buf.extend_from_slice(self.batcher_address.into_word().as_slice());
-        buf.extend_from_slice(self.l1_fee_overhead.to_be_bytes::<32>().as_slice());
-        buf.extend_from_slice(self.l1_fee_scalar.to_be_bytes::<32>().as_slice());
+        buf.extend_from_slice(U256::from(self.number()).to_be_bytes::<32>().as_slice());
+        buf.extend_from_slice(U256::from(self.time()).to_be_bytes::<32>().as_slice());
+        buf.extend_from_slice(U256::from(self.base_fee()).to_be_bytes::<32>().as_slice());
+        buf.extend_from_slice(self.block_hash().as_slice());
+        buf.extend_from_slice(U256::from(self.sequence_number()).to_be_bytes::<32>().as_slice());
+        buf.extend_from_slice(self.batcher_address().into_word().as_slice());
+        buf.extend_from_slice(self.l1_fee_overhead().to_be_bytes::<32>().as_slice());
+        buf.extend_from_slice(self.l1_fee_scalar().to_be_bytes::<32>().as_slice());
         buf.into()
     }
 
@@ -100,7 +151,7 @@ impl L1BlockInfoBedrock {
         let l1_fee_overhead = U256::from_be_slice(r[196..228].as_ref());
         let l1_fee_scalar = U256::from_be_slice(r[228..260].as_ref());
 
-        Ok(Self {
+        Ok(Self::new(
             number,
             time,
             base_fee,
@@ -109,7 +160,69 @@ impl L1BlockInfoBedrock {
             batcher_address,
             l1_fee_overhead,
             l1_fee_scalar,
-        })
+        ))
+    }
+    /// Construct from all values.
+    #[allow(clippy::too_many_arguments)]
+    pub const fn new(
+        number: u64,
+        time: u64,
+        base_fee: u64,
+        block_hash: B256,
+        sequence_number: u64,
+        batcher_address: Address,
+        l1_fee_overhead: U256,
+        l1_fee_scalar: U256,
+    ) -> Self {
+        Self {
+            base: L1BlockInfoBedrockBase::new(
+                number,
+                time,
+                base_fee,
+                block_hash,
+                sequence_number,
+                batcher_address,
+            ),
+            l1_fee_overhead,
+            l1_fee_scalar,
+        }
+    }
+    /// Construct from default values and `base_fee`.
+    pub fn new_from_base_fee(base_fee: u64) -> Self {
+        Self { base: L1BlockInfoBedrockBase::new_from_base_fee(base_fee), ..Default::default() }
+    }
+    /// Construct from default values and `block_hash`.
+    pub fn new_from_block_hash(block_hash: B256) -> Self {
+        Self { base: L1BlockInfoBedrockBase::new_from_block_hash(block_hash), ..Default::default() }
+    }
+    /// Construct from default values and `sequence_number`.
+    pub fn new_from_sequence_number(sequence_number: u64) -> Self {
+        Self {
+            base: L1BlockInfoBedrockBase::new_from_sequence_number(sequence_number),
+            ..Default::default()
+        }
+    }
+    /// Construct from default values and `batcher_address`.
+    pub fn new_from_batcher_address(batcher_address: Address) -> Self {
+        Self {
+            base: L1BlockInfoBedrockBase::new_from_batcher_address(batcher_address),
+            ..Default::default()
+        }
+    }
+    /// Construct from default values and `l1_fee_scalar`.
+    pub fn new_from_l1_fee_scalar(l1_fee_scalar: U256) -> Self {
+        Self { l1_fee_scalar, ..Default::default() }
+    }
+    /// Construct from default values and `l1_fee_overhead`.
+    pub fn new_from_l1_fee_overhead(l1_fee_overhead: U256) -> Self {
+        Self { l1_fee_overhead, ..Default::default() }
+    }
+    /// Construct from default values, `number` and `block_hash`.
+    pub fn new_from_number_and_block_hash(number: u64, block_hash: B256) -> Self {
+        Self {
+            base: L1BlockInfoBedrockBase::new_from_number_and_block_hash(number, block_hash),
+            ..Default::default()
+        }
     }
 }
 
@@ -129,16 +242,16 @@ mod tests {
 
     #[test]
     fn test_l1_block_info_bedrock_roundtrip_calldata_encoding() {
-        let info = L1BlockInfoBedrock {
-            number: 1,
-            time: 2,
-            base_fee: 3,
-            block_hash: B256::from([4u8; 32]),
-            sequence_number: 5,
-            batcher_address: Address::from([6u8; 20]),
-            l1_fee_overhead: U256::from(7),
-            l1_fee_scalar: U256::from(8),
-        };
+        let info = L1BlockInfoBedrock::new(
+            1,
+            2,
+            3,
+            B256::from([4u8; 32]),
+            5,
+            Address::from([6u8; 20]),
+            U256::from(7),
+            U256::from(8),
+        );
 
         let calldata = info.encode_calldata();
         let decoded_info = L1BlockInfoBedrock::decode_calldata(&calldata).unwrap();

crates/protocol/protocol/src/info/bedrock_base.rs

@@ -0,0 +1,100 @@
+use alloy_primitives::{Address, B256};
+
+#[derive(Debug, Clone, Hash, Eq, PartialEq, Default, Copy)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub(crate) struct L1BlockInfoBedrockBase {
+    /// The current L1 origin block number
+    pub number: u64,
+    /// The current L1 origin block's timestamp
+    pub time: u64,
+    /// The current L1 origin block's basefee
+    pub base_fee: u64,
+    /// The current L1 origin block's hash
+    pub block_hash: B256,
+    /// The current sequence number
+    pub sequence_number: u64,
+    /// The address of the batch submitter
+    pub batcher_address: Address,
+}
+
+/// Accessors for Bedrock fields that still are available in latest hardfork.
+pub trait L1BlockInfoBedrockBaseFields {
+    /// The current L1 origin block number
+    fn number(&self) -> u64;
+
+    /// The current L1 origin block's timestamp
+    fn time(&self) -> u64;
+
+    /// The current L1 origin block's basefee
+    fn base_fee(&self) -> u64;
+
+    /// The current L1 origin block's hash
+    fn block_hash(&self) -> B256;
+
+    /// The current sequence number
+    fn sequence_number(&self) -> u64;
+
+    /// The address of the batch new_from_l1_base_feesubmitter
+    fn batcher_address(&self) -> Address;
+}
+
+impl L1BlockInfoBedrockBaseFields for L1BlockInfoBedrockBase {
+    fn number(&self) -> u64 {
+        self.number
+    }
+
+    fn time(&self) -> u64 {
+        self.time
+    }
+
+    fn base_fee(&self) -> u64 {
+        self.base_fee
+    }
+
+    fn block_hash(&self) -> B256 {
+        self.block_hash
+    }
+
+    fn sequence_number(&self) -> u64 {
+        self.sequence_number
+    }
+
+    fn batcher_address(&self) -> Address {
+        self.batcher_address
+    }
+}
+
+impl L1BlockInfoBedrockBase {
+    /// Construct from all values.
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) const fn new(
+        number: u64,
+        time: u64,
+        base_fee: u64,
+        block_hash: B256,
+        sequence_number: u64,
+        batcher_address: Address,
+    ) -> Self {
+        Self { number, time, base_fee, block_hash, sequence_number, batcher_address }
+    }
+    /// Construct from default values and `base_fee`.
+    pub(crate) fn new_from_base_fee(base_fee: u64) -> Self {
+        Self { base_fee, ..Default::default() }
+    }
+    /// Construct from default values and `block_hash`.
+    pub(crate) fn new_from_block_hash(block_hash: B256) -> Self {
+        Self { block_hash, ..Default::default() }
+    }
+    /// Construct from default values and `sequence_number`.
+    pub(crate) fn new_from_sequence_number(sequence_number: u64) -> Self {
+        Self { sequence_number, ..Default::default() }
+    }
+    /// Construct from default values and `batcher_address`.
+    pub(crate) fn new_from_batcher_address(batcher_address: Address) -> Self {
+        Self { batcher_address, ..Default::default() }
+    }
+    /// Construct from default values, `number` and `block_hash`.
+    pub(crate) fn new_from_number_and_block_hash(number: u64, block_hash: B256) -> Self {
+        Self { number, block_hash, ..Default::default() }
+    }
+}