feat(l1): implement osaka EIPs 7918 & 7892 + use BlobSchedule from EFTests (#4284)

**Motivation**
Implement changes defined in
[EIP-7918](https://eips.ethereum.org/EIPS/eip-7918) &
[EIP-7892](https://eips.ethereum.org/EIPS/eip-7892)
Fix EFTests not using the `BlobSchedule` defined in the test files
<!-- Why does this pull request exist? What are its goals? -->

**Description**
* Update `calc_excess_blob_gas` according to EIP
* Add `ForkBlobSchedule`s for Osaka & BPO1-BPO5 forks
* Enable EIP-7918 & EIP-7892  ef tests
* Use the `BlobSchedule` defined in each test file when running EF Tests
<!-- A clear and concise general description of the changes this PR
introduces -->

<!-- Link to issues: Resolves #111, Resolves #222 -->

Closes #4157 & Closes #4156

Author: fmoletta

crates/blockchain/payload.rs

@@ -121,16 +121,11 @@ pub fn create_payload(args: &BuildPayloadArgs, storage: &Store) -> Result<Block,
         .get_block_header_by_hash(args.parent)?
         .ok_or_else(|| ChainError::ParentNotFound)?;
     let chain_config = storage.get_chain_config()?;
+    let fork = chain_config.fork(args.timestamp);
     let gas_limit = calc_gas_limit(parent_block.gas_limit);
     let excess_blob_gas = chain_config
         .get_fork_blob_schedule(args.timestamp)
-        .map(|schedule| {
-            calc_excess_blob_gas(
-                parent_block.excess_blob_gas.unwrap_or_default(),
-                parent_block.blob_gas_used.unwrap_or_default(),
-                schedule.target,
-            )
-        });
+        .map(|schedule| calc_excess_blob_gas(&parent_block, schedule, fork));
 
     let header = BlockHeader {
         parent_hash: args.parent,

crates/common/constants.rs

@@ -57,3 +57,6 @@ pub const GAS_PER_BLOB: u32 = 1 << 17;
 
 // Minimum base fee per blob
 pub const MIN_BASE_FEE_PER_BLOB_GAS: u64 = 1;
+
+// Blob base cost defined in EIP-7918
+pub const BLOB_BASE_COST: u64 = 8192;

crates/common/serde_utils.rs

@@ -139,6 +139,30 @@ pub mod u256 {
     }
 }
 
+pub mod u32 {
+    use super::*;
+
+    pub mod hex_str {
+        use super::*;
+
+        pub fn deserialize<'de, D>(d: D) -> Result<u32, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            let value = String::deserialize(d)?;
+            u32::from_str_radix(value.trim_start_matches("0x"), 16)
+                .map_err(|_| D::Error::custom("Failed to deserialize u32 value"))
+        }
+
+        pub fn serialize<S>(value: &u32, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: Serializer,
+        {
+            serializer.serialize_str(&format!("{value:#x}"))
+        }
+    }
+}
+
 pub mod u64 {
     use serde::de::IntoDeserializer;
 

crates/common/types/block.rs

@@ -1,11 +1,12 @@
 use super::{
-    BASE_FEE_MAX_CHANGE_DENOMINATOR, ChainConfig, GAS_LIMIT_ADJUSTMENT_FACTOR, GAS_LIMIT_MINIMUM,
-    INITIAL_BASE_FEE,
+    BASE_FEE_MAX_CHANGE_DENOMINATOR, ChainConfig, Fork, ForkBlobSchedule,
+    GAS_LIMIT_ADJUSTMENT_FACTOR, GAS_LIMIT_MINIMUM, INITIAL_BASE_FEE,
 };
 use crate::{
     Address, H256, U256,
     constants::{
-        DEFAULT_OMMERS_HASH, EMPTY_WITHDRAWALS_HASH, GAS_PER_BLOB, MIN_BASE_FEE_PER_BLOB_GAS,
+        BLOB_BASE_COST, DEFAULT_OMMERS_HASH, EMPTY_WITHDRAWALS_HASH, GAS_PER_BLOB,
+        MIN_BASE_FEE_PER_BLOB_GAS,
     },
     types::{Receipt, Transaction},
 };
@@ -719,11 +720,7 @@ fn validate_excess_blob_gas(
     let expected_excess_blob_gas = chain_config
         .get_fork_blob_schedule(header.timestamp)
         .map(|schedule| {
-            calc_excess_blob_gas(
-                parent_header.excess_blob_gas.unwrap_or_default(),
-                parent_header.blob_gas_used.unwrap_or_default(),
-                schedule.target,
-            )
+            calc_excess_blob_gas(parent_header, schedule, chain_config.fork(header.timestamp))
         })
         .unwrap_or_default();
     if header
@@ -735,14 +732,31 @@ fn validate_excess_blob_gas(
     Ok(())
 }
 
-pub fn calc_excess_blob_gas(
-    parent_excess_blob_gas: u64,
-    parent_blob_gas_used: u64,
-    target: u32,
-) -> u64 {
+pub fn calc_excess_blob_gas(parent: &BlockHeader, schedule: ForkBlobSchedule, fork: Fork) -> u64 {
+    let parent_blob_gas_used = parent.blob_gas_used.unwrap_or_default();
+    let parent_base_fee_per_gas = parent.base_fee_per_gas.unwrap_or_default();
+    let parent_excess_blob_gas = parent.excess_blob_gas.unwrap_or_default();
+
     let excess_blob_gas = parent_excess_blob_gas + parent_blob_gas_used;
-    let target_blob_gas_per_block = target * GAS_PER_BLOB;
-    excess_blob_gas.saturating_sub(target_blob_gas_per_block.into())
+    let target_blob_gas_per_block = (schedule.target * GAS_PER_BLOB) as u64;
+    if excess_blob_gas < target_blob_gas_per_block {
+        return 0;
+    }
+
+    if fork >= Fork::Osaka
+        && BLOB_BASE_COST * parent_base_fee_per_gas
+            > (GAS_PER_BLOB as u64)
+                * calculate_base_fee_per_blob_gas(
+                    parent_excess_blob_gas,
+                    schedule.base_fee_update_fraction,
+                )
+    {
+        return parent_excess_blob_gas
+            + parent_blob_gas_used * (schedule.max as u64 - schedule.target as u64)
+                / schedule.max as u64;
+    }
+
+    excess_blob_gas - target_blob_gas_per_block
 }
 
 #[cfg(test)]
@@ -913,4 +927,60 @@ mod test {
         );
         assert_eq!(calc_base_fee, expected_base_fee)
     }
+
+    #[test]
+    fn test_calc_blob_fee_post_osaka_bpo1() {
+        let parent = BlockHeader {
+            excess_blob_gas: Some(5149252),
+            blob_gas_used: Some(1310720),
+            base_fee_per_gas: Some(30),
+            ..Default::default()
+        };
+        let schedule = ForkBlobSchedule {
+            target: 9,
+            max: 14,
+            base_fee_update_fraction: 8832827,
+        };
+        let fork = Fork::Osaka;
+
+        let res = calc_excess_blob_gas(&parent, schedule, fork);
+        assert_eq!(res, 5617366)
+    }
+
+    #[test]
+    fn test_calc_blob_fee_post_osaka_bpo3() {
+        let parent = BlockHeader {
+            excess_blob_gas: Some(19251039),
+            blob_gas_used: Some(2490368),
+            base_fee_per_gas: Some(50),
+            ..Default::default()
+        };
+        let schedule = ForkBlobSchedule {
+            target: 21,
+            max: 32,
+            base_fee_update_fraction: 20609697,
+        };
+        let fork = Fork::Osaka;
+        let res = calc_excess_blob_gas(&parent, schedule, fork);
+        assert_eq!(res, 20107103)
+    }
+
+    #[test]
+    fn test_calc_blob_fee_post_osaka_bpo1_ef() {
+        let parent = BlockHeader {
+            excess_blob_gas: Some(0x360000),
+            blob_gas_used: Some(0),
+            base_fee_per_gas: Some(0x11),
+            ..Default::default()
+        };
+        let schedule = ForkBlobSchedule {
+            target: 9,
+            max: 14,
+            base_fee_update_fraction: 0x86c73b,
+        };
+        let fork = Fork::Osaka;
+
+        let res = calc_excess_blob_gas(&parent, schedule, fork);
+        assert_eq!(res, 3538944)
+    }
 }

crates/common/types/genesis.rs

@@ -85,13 +85,31 @@ impl TryFrom<&Path> for Genesis {
             warn!("Invalid fork, only post-merge networks are supported.");
         }
 
+        if genesis.config.bpo1_time.is_some() && genesis.config.blob_schedule.bpo1.is_none()
+            || genesis.config.bpo2_time.is_some() && genesis.config.blob_schedule.bpo2.is_none()
+            || genesis.config.bpo3_time.is_some() && genesis.config.blob_schedule.bpo3.is_none()
+            || genesis.config.bpo4_time.is_some() && genesis.config.blob_schedule.bpo4.is_none()
+            || genesis.config.bpo5_time.is_some() && genesis.config.blob_schedule.bpo5.is_none()
+        {
+            warn!("BPO time set but no BPO BlobSchedule found in ChainConfig")
+        }
+
         Ok(genesis)
     }
 }
 
 #[allow(unused)]
 #[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, PartialEq, RSerialize, RDeserialize, Archive,
+    Clone,
+    Copy,
+    Debug,
+    Serialize,
+    Deserialize,
+    PartialEq,
+    RSerialize,
+    RDeserialize,
+    Archive,
+    Default,
 )]
 #[serde(rename_all = "camelCase")]
 pub struct ForkBlobSchedule {
@@ -110,13 +128,31 @@ pub struct BlobSchedule {
     pub cancun: ForkBlobSchedule,
     #[serde(default = "default_prague_schedule")]
     pub prague: ForkBlobSchedule,
+    #[serde(default = "default_osaka_schedule")]
+    pub osaka: ForkBlobSchedule,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub bpo1: Option<ForkBlobSchedule>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub bpo2: Option<ForkBlobSchedule>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub bpo3: Option<ForkBlobSchedule>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub bpo4: Option<ForkBlobSchedule>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub bpo5: Option<ForkBlobSchedule>,
 }
 
 impl Default for BlobSchedule {
     fn default() -> Self {
         BlobSchedule {
             cancun: default_cancun_schedule(),
             prague: default_prague_schedule(),
+            osaka: default_osaka_schedule(),
+            bpo1: None,
+            bpo2: None,
+            bpo3: None,
+            bpo4: None,
+            bpo5: None,
         }
     }
 }
@@ -137,6 +173,14 @@ fn default_prague_schedule() -> ForkBlobSchedule {
     }
 }
 
+fn default_osaka_schedule() -> ForkBlobSchedule {
+    ForkBlobSchedule {
+        target: 6,
+        max: 9,
+        base_fee_update_fraction: 5007716,
+    }
+}
+
 /// Blockchain settings defined per block
 #[allow(unused)]
 #[derive(
@@ -276,6 +320,26 @@ impl From<Fork> for &str {
 }
 
 impl ChainConfig {
+    pub fn is_bpo1_activated(&self, block_timestamp: u64) -> bool {
+        self.bpo1_time.is_some_and(|time| time <= block_timestamp)
+    }
+
+    pub fn is_bpo2_activated(&self, block_timestamp: u64) -> bool {
+        self.bpo2_time.is_some_and(|time| time <= block_timestamp)
+    }
+
+    pub fn is_bpo3_activated(&self, block_timestamp: u64) -> bool {
+        self.bpo3_time.is_some_and(|time| time <= block_timestamp)
+    }
+
+    pub fn is_bpo4_activated(&self, block_timestamp: u64) -> bool {
+        self.bpo4_time.is_some_and(|time| time <= block_timestamp)
+    }
+
+    pub fn is_bpo5_activated(&self, block_timestamp: u64) -> bool {
+        self.bpo5_time.is_some_and(|time| time <= block_timestamp)
+    }
+
     pub fn is_osaka_activated(&self, block_timestamp: u64) -> bool {
         self.osaka_time.is_some_and(|time| time <= block_timestamp)
     }
@@ -348,7 +412,19 @@ impl ChainConfig {
     }
 
     pub fn get_fork_blob_schedule(&self, block_timestamp: u64) -> Option<ForkBlobSchedule> {
-        if self.is_prague_activated(block_timestamp) {
+        if self.is_bpo5_activated(block_timestamp) {
+            Some(self.blob_schedule.bpo5.unwrap_or_default())
+        } else if self.is_bpo4_activated(block_timestamp) {
+            Some(self.blob_schedule.bpo4.unwrap_or_default())
+        } else if self.is_bpo3_activated(block_timestamp) {
+            Some(self.blob_schedule.bpo3.unwrap_or_default())
+        } else if self.is_bpo2_activated(block_timestamp) {
+            Some(self.blob_schedule.bpo2.unwrap_or_default())
+        } else if self.is_bpo1_activated(block_timestamp) {
+            Some(self.blob_schedule.bpo1.unwrap_or_default())
+        } else if self.is_osaka_activated(block_timestamp) {
+            Some(self.blob_schedule.osaka)
+        } else if self.is_prague_activated(block_timestamp) {
             Some(self.blob_schedule.prague)
         } else if self.is_cancun_activated(block_timestamp) {
             Some(self.blob_schedule.cancun)
@@ -559,6 +635,7 @@ mod tests {
                     max: 4,
                     base_fee_update_fraction: 13353908,
                 },
+                ..Default::default()
             },
             ..Default::default()
         };
@@ -734,6 +811,7 @@ mod tests {
                     max: 4,
                     base_fee_update_fraction: 20000,
                 },
+                ..Default::default()
             },
             deposit_contract_address: H160::from_str("0x4242424242424242424242424242424242424242")
                 .unwrap(),
@@ -766,6 +844,7 @@ mod tests {
                     max: 9,
                     base_fee_update_fraction: 5007716,
                 },
+                ..Default::default()
             },
             deposit_contract_address: H160::from_str("0x4242424242424242424242424242424242424242")
                 .unwrap(),
@@ -805,6 +884,7 @@ mod tests {
                     max: 4,
                     base_fee_update_fraction: 20000,
                 },
+                ..Default::default()
             },
             deposit_contract_address: H160::from_str("0x4242424242424242424242424242424242424242")
                 .unwrap(),
@@ -844,6 +924,7 @@ mod tests {
                     max: 9,
                     base_fee_update_fraction: 5007716,
                 },
+                ..Default::default()
             },
             deposit_contract_address: H160::from_str("0x4242424242424242424242424242424242424242")
                 .unwrap(),