fix: use blobparams for blob fee calc (#12056)

* fix: use blobparams for blob fee calc

* clippy

Author: mattsse

crates/anvil/src/config.rs

@@ -17,6 +17,7 @@ use crate::{
 };
 use alloy_chains::Chain;
 use alloy_consensus::BlockHeader;
+use alloy_eips::eip7840::BlobParams;
 use alloy_genesis::Genesis;
 use alloy_network::{AnyNetwork, TransactionResponse};
 use alloy_op_hardforks::OpHardfork;
@@ -65,7 +66,10 @@ use tokio::sync::RwLock as TokioRwLock;
 use yansi::Paint;
 
 pub use foundry_common::version::SHORT_VERSION as VERSION_MESSAGE;
-use foundry_evm::traces::{CallTraceDecoderBuilder, identifier::SignaturesIdentifier};
+use foundry_evm::{
+    traces::{CallTraceDecoderBuilder, identifier::SignaturesIdentifier},
+    utils::get_blob_params,
+};
 use foundry_evm_networks::NetworkConfigs;
 
 /// Default port the rpc will open
@@ -533,6 +537,14 @@ impl NodeConfig {
         }
     }
 
+    /// Returns the [`BlobParams`] that should be used.
+    pub fn get_blob_params(&self) -> BlobParams {
+        get_blob_params(
+            self.chain_id.unwrap_or(Chain::mainnet().id()),
+            self.get_genesis_timestamp(),
+        )
+    }
+
     /// Returns the hardfork to use
     pub fn get_hardfork(&self) -> ChainHardfork {
         if let Some(hardfork) = self.hardfork {
@@ -1083,6 +1095,7 @@ impl NodeConfig {
             !self.disable_min_priority_fee,
             self.get_gas_price(),
             self.get_blob_excess_gas_and_price(),
+            self.get_blob_params(),
         );
 
         let (db, fork): (Arc<TokioRwLock<Box<dyn Db>>>, Option<ClientFork>) =
@@ -1297,7 +1310,8 @@ latest block number: {latest_block}"
             if let (Some(blob_excess_gas), Some(blob_gas_used)) =
                 (block.header.excess_blob_gas, block.header.blob_gas_used)
             {
-                let blob_base_fee_update_fraction = get_blob_base_fee_update_fraction(
+                // derive the blobparams that are active at this timestamp
+                let blob_params = get_blob_params(
                     fork_chain_id
                         .unwrap_or_else(|| U256::from(Chain::mainnet().id()))
                         .saturating_to(),
@@ -1306,15 +1320,16 @@ latest block number: {latest_block}"
 
                 env.evm_env.block_env.blob_excess_gas_and_price = Some(BlobExcessGasAndPrice::new(
                     blob_excess_gas,
-                    blob_base_fee_update_fraction,
+                    blob_params.update_fraction as u64,
                 ));
 
+                fees.set_blob_params(blob_params);
+
                 let next_block_blob_excess_gas =
                     fees.get_next_block_blob_excess_gas(blob_excess_gas, blob_gas_used);
-
                 fees.set_blob_excess_gas_and_price(BlobExcessGasAndPrice::new(
                     next_block_blob_excess_gas,
-                    blob_base_fee_update_fraction,
+                    blob_params.update_fraction as u64,
                 ));
             }
         }

crates/anvil/src/eth/backend/mem/mod.rs

@@ -1149,11 +1149,15 @@ impl Backend {
     }
 
     /// Returns the environment for the next block
+    ///
+    /// This is used for obtaining the evm environment for the next (pending) block (e.g.
+    /// transaction validation in eth_sendrawTransaction)
     fn next_env(&self) -> Env {
         let mut env = self.env.read().clone();
         // increase block number for this block
         env.evm_env.block_env.number = env.evm_env.block_env.number.saturating_add(U256::from(1));
         env.evm_env.block_env.basefee = self.base_fee();
+        env.evm_env.block_env.blob_excess_gas_and_price = self.excess_blob_gas_and_price();
         env.evm_env.block_env.timestamp = U256::from(self.time.current_call_timestamp());
         env
     }

crates/anvil/src/eth/fees.rs

@@ -46,6 +46,8 @@ pub fn default_elasticity() -> f64 {
 pub struct FeeManager {
     /// Hardfork identifier
     spec_id: SpecId,
+    /// The blob params that determine blob fees
+    blob_params: Arc<RwLock<BlobParams>>,
     /// Tracks the base fee for the next block post London
     ///
     /// This value will be updated after a new block was mined
@@ -70,9 +72,11 @@ impl FeeManager {
         is_min_priority_fee_enforced: bool,
         gas_price: u128,
         blob_excess_gas_and_price: BlobExcessGasAndPrice,
+        blob_params: BlobParams,
     ) -> Self {
         Self {
             spec_id,
+            blob_params: Arc::new(RwLock::new(blob_params)),
             base_fee: Arc::new(RwLock::new(base_fee)),
             is_min_priority_fee_enforced,
             gas_price: Arc::new(RwLock::new(gas_price)),
@@ -158,15 +162,27 @@ impl FeeManager {
 
     /// Calculates the next block blob base fee.
     pub fn get_next_block_blob_base_fee_per_gas(&self) -> u128 {
-        alloy_eips::eip4844::calc_blob_gasprice(
-            self.blob_excess_gas_and_price.read().excess_blob_gas,
-        )
+        self.blob_params().calc_blob_fee(self.blob_excess_gas_and_price.read().excess_blob_gas)
     }
 
     /// Calculates the next block blob excess gas, using the provided parent blob gas used and
     /// parent blob excess gas
     pub fn get_next_block_blob_excess_gas(&self, blob_gas_used: u64, blob_excess_gas: u64) -> u64 {
-        alloy_eips::eip4844::calc_excess_blob_gas(blob_gas_used, blob_excess_gas)
+        self.blob_params().next_block_excess_blob_gas_osaka(
+            blob_excess_gas,
+            blob_gas_used,
+            self.base_fee(),
+        )
+    }
+
+    /// Configures the blob params
+    pub fn set_blob_params(&self, blob_params: BlobParams) {
+        *self.blob_params.write() = blob_params;
+    }
+
+    /// Returns the active [`BlobParams`]
+    pub fn blob_params(&self) -> BlobParams {
+        *self.blob_params.read()
     }
 }
 

crates/anvil/tests/it/eip4844.rs

@@ -7,7 +7,7 @@ use alloy_eips::{
 use alloy_hardforks::EthereumHardfork;
 use alloy_network::{EthereumWallet, ReceiptResponse, TransactionBuilder, TransactionBuilder4844};
 use alloy_primitives::{Address, U256, b256};
-use alloy_provider::Provider;
+use alloy_provider::{Provider, ProviderBuilder};
 use alloy_rpc_types::{BlockId, TransactionRequest};
 use alloy_serde::WithOtherFields;
 use anvil::{NodeConfig, spawn};
@@ -76,6 +76,33 @@ async fn can_send_eip4844_transaction_fork() {
     let _blobs = api.anvil_get_blob_by_tx_hash(tx_hash).unwrap().unwrap();
 }
 
+#[tokio::test(flavor = "multi_thread")]
+async fn can_send_eip4844_transaction_eth_send_transaction() {
+    let node_config = NodeConfig::test()
+        .with_eth_rpc_url(Some(rpc::next_http_archive_rpc_url()))
+        .with_fork_block_number(Some(23552208u64))
+        .with_hardfork(Some(EthereumHardfork::Cancun.into()));
+    let (api, handle) = spawn(node_config).await;
+    let provider = ProviderBuilder::new().connect(handle.http_endpoint().as_str()).await.unwrap();
+    let accounts = provider.get_accounts().await.unwrap();
+    let alice = accounts[0];
+    let bob = accounts[1];
+
+    let sidecar: SidecarBuilder<SimpleCoder> = SidecarBuilder::from_slice(b"Blobs are fun!");
+    let sidecar = sidecar.build().unwrap();
+
+    let tx = TransactionRequest::default()
+        .with_from(alice)
+        .with_to(bob)
+        .with_blob_sidecar(sidecar.clone());
+
+    let pending_tx = provider.send_transaction(tx).await.unwrap();
+    let receipt = pending_tx.get_receipt().await.unwrap();
+    let tx_hash = receipt.transaction_hash;
+
+    let _blobs = api.anvil_get_blob_by_tx_hash(tx_hash).unwrap().unwrap();
+}
+
 #[tokio::test(flavor = "multi_thread")]
 async fn can_send_multiple_blobs_in_one_tx() {
     let node_config = NodeConfig::test().with_hardfork(Some(EthereumHardfork::Cancun.into()));

crates/evm/core/src/utils.rs

@@ -1,6 +1,6 @@
 use crate::EnvMut;
 use alloy_chains::Chain;
-use alloy_consensus::BlockHeader;
+use alloy_consensus::{BlockHeader, private::alloy_eips::eip7840::BlobParams};
 use alloy_hardforks::EthereumHardfork;
 use alloy_json_abi::{Function, JsonAbi};
 use alloy_network::{AnyTxEnvelope, TransactionResponse};
@@ -84,19 +84,37 @@ pub fn apply_chain_and_block_specific_env_changes<N: Network>(
     }
 }
 
-/// Derive the blob base fee update fraction based on the chain and timestamp by checking the
-/// hardfork.
-pub fn get_blob_base_fee_update_fraction(chain_id: ChainId, timestamp: u64) -> u64 {
+/// Derives the active [`BlobParams`] based on the given timestamp.
+///
+/// This falls back to regular ethereum blob params if no hardforks for the given chain id are
+/// detected.
+pub fn get_blob_params(chain_id: ChainId, timestamp: u64) -> BlobParams {
     let hardfork = EthereumHardfork::from_chain_and_timestamp(Chain::from_id(chain_id), timestamp)
         .unwrap_or_default();
 
-    if hardfork >= EthereumHardfork::Prague {
-        BLOB_BASE_FEE_UPDATE_FRACTION_PRAGUE
-    } else {
-        BLOB_BASE_FEE_UPDATE_FRACTION_CANCUN
+    match hardfork {
+        EthereumHardfork::Prague => BlobParams::prague(),
+        EthereumHardfork::Osaka => BlobParams::osaka(),
+        EthereumHardfork::Bpo1 => BlobParams::bpo1(),
+        EthereumHardfork::Bpo2 => BlobParams::bpo2(),
+
+        // future hardforks/unknown settings: update once decided
+        EthereumHardfork::Bpo3 => BlobParams::bpo2(),
+        EthereumHardfork::Bpo4 => BlobParams::bpo2(),
+        EthereumHardfork::Bpo5 => BlobParams::bpo2(),
+        EthereumHardfork::Amsterdam => BlobParams::bpo2(),
+
+        // fallback
+        _ => BlobParams::cancun(),
     }
 }
 
+/// Derive the blob base fee update fraction based on the chain and timestamp by checking the
+/// hardfork.
+pub fn get_blob_base_fee_update_fraction(chain_id: ChainId, timestamp: u64) -> u64 {
+    get_blob_params(chain_id, timestamp).update_fraction as u64
+}
+
 /// Returns the blob base fee update fraction based on the spec id.
 pub fn get_blob_base_fee_update_fraction_by_spec_id(spec: SpecId) -> u64 {
     if spec >= SpecId::PRAGUE {