feat(anvil): bypass sidecar requirement when impersonating (#10224)

Author: yash-atreya

crates/anvil/core/src/eth/transaction/mod.rs

@@ -83,7 +83,7 @@ pub fn transaction_request_to_typed(
         access_list.as_ref(),
         max_fee_per_blob_gas,
         blob_versioned_hashes.as_ref(),
-        sidecar,
+        sidecar.as_ref(),
         to,
     ) {
         // legacy transaction
@@ -132,7 +132,7 @@ pub fn transaction_request_to_typed(
             }))
         }
         // EIP4844
-        (Some(3), None, _, _, _, _, Some(_), Some(sidecar), to) => {
+        (Some(3), None, _, _, _, _, Some(_), _, to) => {
             let tx = TxEip4844 {
                 nonce: nonce.unwrap_or_default(),
                 max_fee_per_gas: max_fee_per_gas.unwrap_or_default(),
@@ -149,9 +149,14 @@ pub fn transaction_request_to_typed(
                 access_list: access_list.unwrap_or_default(),
                 blob_versioned_hashes: blob_versioned_hashes.unwrap_or_default(),
             };
-            Some(TypedTransactionRequest::EIP4844(TxEip4844Variant::TxEip4844WithSidecar(
-                TxEip4844WithSidecar::from_tx_and_sidecar(tx, sidecar),
-            )))
+
+            if let Some(sidecar) = sidecar {
+                Some(TypedTransactionRequest::EIP4844(TxEip4844Variant::TxEip4844WithSidecar(
+                    TxEip4844WithSidecar::from_tx_and_sidecar(tx, sidecar),
+                )))
+            } else {
+                Some(TypedTransactionRequest::EIP4844(TxEip4844Variant::TxEip4844(tx)))
+            }
         }
         _ => None,
     }

crates/anvil/src/eth/api.rs

@@ -2884,6 +2884,7 @@ impl EthApi {
         let gas_price = request.gas_price;
 
         let gas_limit = request.gas.unwrap_or_else(|| self.backend.gas_limit());
+        let from = request.from;
 
         let request = match transaction_request_to_typed(request) {
             Some(TypedTransactionRequest::Legacy(mut m)) => {
@@ -2931,10 +2932,26 @@ impl EthApi {
                         }
                         TxEip4844Variant::TxEip4844WithSidecar(m)
                     }
-                    // It is not valid to receive a TxEip4844 without a sidecar, therefore
-                    // we must reject it.
-                    TxEip4844Variant::TxEip4844(_) => {
-                        return Err(BlockchainError::FailedToDecodeTransaction)
+                    TxEip4844Variant::TxEip4844(mut tx) => {
+                        if !self.backend.skip_blob_validation(from) {
+                            return Err(BlockchainError::FailedToDecodeTransaction)
+                        }
+
+                        // Allows 4844 with no sidecar when impersonation is active.
+                        tx.nonce = nonce;
+                        tx.chain_id = chain_id;
+                        tx.gas_limit = gas_limit;
+                        if max_fee_per_gas.is_none() {
+                            tx.max_fee_per_gas = self.gas_price();
+                        }
+                        if max_fee_per_blob_gas.is_none() {
+                            tx.max_fee_per_blob_gas = self
+                                .excess_blob_gas_and_price()
+                                .unwrap_or_default()
+                                .map_or(0, |g| g.blob_gasprice)
+                        }
+
+                        TxEip4844Variant::TxEip4844(tx)
                     }
                 })
             }

crates/anvil/src/eth/backend/cheats.rs

@@ -40,13 +40,18 @@ impl CheatsManager {
 
     /// Returns true if the `addr` is currently impersonated
     pub fn is_impersonated(&self, addr: Address) -> bool {
-        if self.state.read().auto_impersonate_accounts {
+        if self.auto_impersonate_accounts() {
             true
         } else {
             self.state.read().impersonated_accounts.contains(&addr)
         }
     }
 
+    /// Returns true is auto impersonation is enabled
+    pub fn auto_impersonate_accounts(&self) -> bool {
+        self.state.read().auto_impersonate_accounts
+    }
+
     /// Sets the auto impersonation flag which if set to true will make the `is_impersonated`
     /// function always return true
     pub fn set_auto_impersonate_account(&self, enabled: bool) {

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

@@ -623,6 +623,13 @@ impl Backend {
         &self.cheats
     }
 
+    /// Whether to skip blob validation
+    pub fn skip_blob_validation(&self, impersonator: Option<Address>) -> bool {
+        self.cheats().auto_impersonate_accounts() ||
+            impersonator
+                .is_some_and(|addr| self.cheats().impersonated_accounts().contains(&addr))
+    }
+
     /// Returns the `FeeManager` that manages fee/pricings
     pub fn fees(&self) -> &FeeManager {
         &self.fees
@@ -2825,9 +2832,11 @@ impl TransactionValidator for Backend {
                 return Err(InvalidTransactionError::TooManyBlobs(blob_count))
             }
 
-            // Check for any blob validation errors
-            if let Err(err) = tx.validate(env.cfg.kzg_settings.get()) {
-                return Err(InvalidTransactionError::BlobTransactionValidationError(err))
+            // Check for any blob validation errors if not impersonating.
+            if !self.skip_blob_validation(Some(*pending.sender())) {
+                if let Err(err) = tx.validate(env.cfg.kzg_settings.get()) {
+                    return Err(InvalidTransactionError::BlobTransactionValidationError(err))
+                }
             }
         }
 

crates/anvil/tests/it/eip4844.rs

@@ -1,8 +1,11 @@
 use crate::utils::{http_provider, http_provider_with_signer};
 use alloy_consensus::{SidecarBuilder, SimpleCoder, Transaction};
-use alloy_eips::eip4844::{BLOB_TX_MIN_BLOB_GASPRICE, DATA_GAS_PER_BLOB, MAX_DATA_GAS_PER_BLOCK};
-use alloy_network::{EthereumWallet, TransactionBuilder, TransactionBuilder4844};
-use alloy_primitives::U256;
+use alloy_eips::{
+    eip4844::{BLOB_TX_MIN_BLOB_GASPRICE, DATA_GAS_PER_BLOB, MAX_DATA_GAS_PER_BLOCK},
+    Typed2718,
+};
+use alloy_network::{EthereumWallet, ReceiptResponse, TransactionBuilder, TransactionBuilder4844};
+use alloy_primitives::{b256, Address, U256};
 use alloy_provider::Provider;
 use alloy_rpc_types::{BlockId, TransactionRequest};
 use alloy_serde::WithOtherFields;
@@ -293,3 +296,52 @@ async fn can_correctly_estimate_blob_gas_with_recommended_fillers_with_signer()
         DATA_GAS_PER_BLOB
     );
 }
+
+// <https://github.com/foundry-rs/foundry/issues/9924>
+#[tokio::test]
+async fn can_bypass_sidecar_requirement() {
+    tracing_subscriber::fmt::init();
+    let node_config = NodeConfig::test()
+        .with_hardfork(Some(EthereumHardfork::Cancun.into()))
+        .with_auto_impersonate(true);
+    let (api, handle) = spawn(node_config).await;
+    let provider = http_provider(&handle.http_endpoint());
+
+    let eip1559_est = provider.estimate_eip1559_fees().await.unwrap();
+    let gas_price = provider.get_gas_price().await.unwrap();
+
+    let from = Address::random();
+    let to = Address::random();
+
+    api.anvil_set_balance(from, U256::from(60262144030131080_u128)).await.unwrap();
+
+    let tx = TransactionRequest {
+        from: Some(from),
+        to: Some(alloy_primitives::TxKind::Call(to)),
+        nonce: Some(0),
+        value: Some(U256::from(0)),
+        max_fee_per_blob_gas: Some(gas_price + 1),
+        max_fee_per_gas: Some(eip1559_est.max_fee_per_gas),
+        max_priority_fee_per_gas: Some(eip1559_est.max_priority_fee_per_gas),
+        blob_versioned_hashes: Some(vec![b256!(
+            "0x01d5446006b21888d0267829344ab8624fdf1b425445a8ae1ca831bf1b8fbcd4"
+        )]),
+        sidecar: None,
+        transaction_type: Some(3),
+        ..Default::default()
+    };
+
+    let receipt = provider
+        .send_transaction(WithOtherFields::new(tx))
+        .await
+        .unwrap()
+        .get_receipt()
+        .await
+        .unwrap();
+
+    assert!(receipt.status());
+
+    let tx = provider.get_transaction_by_hash(receipt.transaction_hash).await.unwrap().unwrap();
+
+    assert_eq!(tx.inner.ty(), 3);
+}