chore: use alloy state override on anvil (#6766)

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

@@ -14,7 +14,6 @@ use ethers_core::types::transaction::eip712::TypedData;
 pub mod block;
 pub mod proof;
 pub mod receipt;
-pub mod state;
 pub mod subscription;
 pub mod transaction;
 pub mod trie;

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

@@ -3,7 +3,6 @@
 use super::EthTransactionRequest;
 use crate::eth::{
     proof::AccountProof,
-    state::{AccountOverride, StateOverride as EthStateOverride},
     transaction::{
         DepositTransactionRequest, EIP1559TransactionRequest, EIP2930TransactionRequest,
         LegacyTransactionRequest, MaybeImpersonatedTransaction, TypedTransaction,
@@ -12,7 +11,6 @@ use crate::eth::{
 };
 use alloy_primitives::{U128 as rU128, U256 as rU256, U64 as rU64};
 use alloy_rpc_types::{
-    state::{AccountOverride as AlloyAccountOverride, StateOverride},
     transaction::request::TransactionRequest as AlloyTransactionRequest,
     AccessList as AlloyAccessList, CallRequest, Signature, Transaction as AlloyTransaction,
 };
@@ -118,56 +116,6 @@ pub fn from_ethers_access_list(access_list: AccessList) -> AlloyAccessList {
     AlloyAccessList(access_list.0.into_iter().map(ToAlloy::to_alloy).collect())
 }
 
-pub fn to_ethers_state_override(ov: StateOverride) -> EthStateOverride {
-    ov.into_iter()
-        .map(|(addr, o)| {
-            (
-                addr.to_ethers(),
-                AccountOverride {
-                    nonce: o.nonce.map(|n| n.to::<u64>()),
-                    balance: o.balance.map(|b| b.to_ethers()),
-                    code: o.code.map(|c| c.0.into()),
-                    state_diff: o.state_diff.map(|s| {
-                        s.into_iter()
-                            .map(|(k, v)| (k.to_ethers(), H256::from_uint(&v.to_ethers())))
-                            .collect()
-                    }),
-                    state: o.state.map(|s| {
-                        s.into_iter()
-                            .map(|(k, v)| (k.to_ethers(), H256::from_uint(&v.to_ethers())))
-                            .collect()
-                    }),
-                },
-            )
-        })
-        .collect()
-}
-
-pub fn to_alloy_state_override(ov: EthStateOverride) -> StateOverride {
-    ov.into_iter()
-        .map(|(addr, o)| {
-            (
-                addr.to_alloy(),
-                AlloyAccountOverride {
-                    nonce: o.nonce.map(rU64::from),
-                    balance: o.balance.map(|b| b.to_alloy()),
-                    code: o.code.map(|c| c.0.into()),
-                    state_diff: o.state_diff.map(|s| {
-                        s.into_iter()
-                            .map(|(k, v)| (k.to_alloy(), rU256::from_be_bytes(v.to_alloy().0)))
-                            .collect()
-                    }),
-                    state: o.state.map(|s| {
-                        s.into_iter()
-                            .map(|(k, v)| (k.to_alloy(), rU256::from_be_bytes(v.to_alloy().0)))
-                            .collect()
-                    }),
-                },
-            )
-        })
-        .collect()
-}
-
 impl From<TypedTransactionRequest> for EthersTypedTransactionRequest {
     fn from(tx: TypedTransactionRequest) -> Self {
         match tx {

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

@@ -26,8 +26,8 @@ use std::ops::Deref;
 mod ethers_compat;
 
 pub use ethers_compat::{
-    call_to_internal_tx_request, from_ethers_access_list, to_alloy_proof, to_alloy_state_override,
-    to_ethers_access_list, to_ethers_state_override, to_internal_tx_request,
+    call_to_internal_tx_request, from_ethers_access_list, to_alloy_proof, to_ethers_access_list,
+    to_internal_tx_request,
 };
 
 /// The signature used to bypass signing via the `eth_sendUnsignedTransaction` cheat RPC

crates/anvil/tests/it/api.rs

@@ -1,21 +1,23 @@
 //! general eth api tests
 
 use crate::abi::{MulticallContract, SimpleStorage};
-use alloy_primitives::U256 as rU256;
-use alloy_rpc_types::{CallInput, CallRequest};
+use alloy_primitives::{B256, U256 as rU256};
+use alloy_rpc_types::{
+    state::{AccountOverride, StateOverride},
+    CallInput, CallRequest,
+};
 use anvil::{
     eth::{api::CLIENT_VERSION, EthApi},
     spawn, NodeConfig, CHAIN_ID,
 };
-use anvil_core::eth::{state::AccountOverride, transaction::to_alloy_state_override};
 use ethers::{
     abi::{Address, Tokenizable},
     prelude::{builders::ContractCall, decode_function_data, Middleware, SignerMiddleware},
     signers::Signer,
-    types::{Block, BlockNumber, Chain, Transaction, TransactionRequest, H256, U256},
+    types::{Block, BlockNumber, Chain, Transaction, TransactionRequest, U256},
     utils::get_contract_address,
 };
-use foundry_common::types::ToAlloy;
+use foundry_common::types::{ToAlloy, ToEthers};
 use std::{collections::HashMap, sync::Arc, time::Duration};
 
 #[tokio::test(flavor = "multi_thread")]
@@ -227,7 +229,7 @@ async fn call_with_override<M, D>(
     api: &EthApi,
     call: ContractCall<M, D>,
     to: Address,
-    overrides: HashMap<Address, AccountOverride>,
+    overrides: StateOverride,
 ) -> D
 where
     D: Tokenizable,
@@ -240,7 +242,7 @@ where
                 ..Default::default()
             },
             None,
-            Some(to_alloy_state_override(overrides)),
+            Some(overrides),
         )
         .await
         .unwrap();
@@ -268,25 +270,28 @@ async fn can_call_with_state_override() {
         .unwrap();
 
     // Test the `balance` account override
-    let balance = 42u64.into();
+    let balance = rU256::from(42u64);
     let result = call_with_override(
         &api,
         multicall.get_eth_balance(account),
         multicall.address(),
         HashMap::from([(
-            account,
+            account.to_alloy(),
             AccountOverride { balance: Some(balance), ..Default::default() },
         )]),
     )
     .await;
-    assert_eq!(result, balance);
+    assert_eq!(result, balance.to_ethers());
 
     // Test the `state_diff` account override
     let overrides = HashMap::from([(
-        simple_storage.address(),
+        simple_storage.address().to_alloy(),
         AccountOverride {
             // The `lastSender` is in the first storage slot
-            state_diff: Some(HashMap::from([(H256::from_low_u64_be(0), account.into())])),
+            state_diff: Some(HashMap::from([(
+                B256::ZERO,
+                rU256::from_be_slice(B256::from(account.to_alloy().into_word()).as_slice()),
+            )])),
             ..Default::default()
         },
     )]);
@@ -317,10 +322,13 @@ async fn can_call_with_state_override() {
 
     // Test the `state` account override
     let overrides = HashMap::from([(
-        simple_storage.address(),
+        simple_storage.address().to_alloy(),
         AccountOverride {
             // The `lastSender` is in the first storage slot
-            state: Some(HashMap::from([(H256::from_low_u64_be(0), account.into())])),
+            state: Some(HashMap::from([(
+                B256::ZERO,
+                rU256::from_be_slice(B256::from(account.to_alloy().into_word()).as_slice()),
+            )])),
             ..Default::default()
         },
     )]);