fix: correctly apply genesis (#8431)

* Add test

* fix: correctly apply genesis during fork reset

Author: klkvr

crates/anvil/src/config.rs

@@ -947,7 +947,6 @@ impl NodeConfig {
             timestamp: self.get_genesis_timestamp(),
             balance: self.genesis_balance,
             accounts: self.genesis_accounts.iter().map(|acc| acc.address()).collect(),
-            fork_genesis_account_infos: Arc::new(Default::default()),
             genesis_init: self.genesis.clone(),
         };
 

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

@@ -7,8 +7,6 @@ use foundry_evm::{
     backend::DatabaseResult,
     revm::primitives::{AccountInfo, Bytecode, KECCAK_EMPTY},
 };
-use parking_lot::Mutex;
-use std::sync::Arc;
 use tokio::sync::RwLockWriteGuard;
 
 /// Genesis settings
@@ -20,11 +18,6 @@ pub struct GenesisConfig {
     pub balance: U256,
     /// All accounts that should be initialised at genesis
     pub accounts: Vec<Address>,
-    /// The account object stored in the [`revm::Database`]
-    ///
-    /// We store this for forking mode so we can cheaply reset the dev accounts and don't
-    /// need to fetch them again.
-    pub fork_genesis_account_infos: Arc<Mutex<Vec<AccountInfo>>>,
     /// The `genesis.json` if provided
     pub genesis_init: Option<Genesis>,
 }

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

@@ -64,7 +64,7 @@ use anvil_core::eth::{
 use anvil_rpc::error::RpcError;
 use flate2::{read::GzDecoder, write::GzEncoder, Compression};
 use foundry_evm::{
-    backend::{BackendError, BackendResult, DatabaseError, DatabaseResult, RevertSnapshotAction},
+    backend::{DatabaseError, DatabaseResult, RevertSnapshotAction},
     constants::DEFAULT_CREATE2_DEPLOYER_RUNTIME_CODE,
     decode::RevertDecoder,
     inspectors::AccessListInspector,
@@ -277,7 +277,7 @@ impl Backend {
     /// Applies the configured genesis settings
     ///
     /// This will fund, create the genesis accounts
-    async fn apply_genesis(&self) -> BackendResult<()> {
+    async fn apply_genesis(&self) -> Result<(), DatabaseError> {
         trace!(target: "backend", "setting genesis balances");
 
         if self.fork.read().is_some() {
@@ -291,27 +291,18 @@ impl Backend {
                 genesis_accounts_futures.push(tokio::task::spawn(async move {
                     let db = db.read().await;
                     let info = db.basic_ref(address)?.unwrap_or_default();
-                    Ok::<_, BackendError>((address, info))
+                    Ok::<_, DatabaseError>((address, info))
                 }));
             }
 
             let genesis_accounts = futures::future::join_all(genesis_accounts_futures).await;
 
             let mut db = self.db.write().await;
 
-            // in fork mode we only set the balance, this way the accountinfo is fetched from the
-            // remote client, preserving code and nonce. The reason for that is private keys for dev
-            // accounts are commonly known and are used on testnets
-            let mut fork_genesis_infos = self.genesis.fork_genesis_account_infos.lock();
-            fork_genesis_infos.clear();
-
             for res in genesis_accounts {
-                let (address, mut info) = res.map_err(BackendError::display)??;
+                let (address, mut info) = res.unwrap()?;
                 info.balance = self.genesis.balance;
                 db.insert_account(address, info.clone());
-
-                // store the fetched AccountInfo, so we can cheaply reset in [Self::reset_fork()]
-                fork_genesis_infos.push(info);
             }
         } else {
             let mut db = self.db.write().await;
@@ -459,23 +450,9 @@ impl Backend {
                 fork.total_difficulty(),
             );
             self.states.write().clear();
+            self.db.write().await.clear();
 
-            // insert back all genesis accounts, by reusing cached `AccountInfo`s we don't need to
-            // fetch the data via RPC again
-            let mut db = self.db.write().await;
-
-            // clear database
-            db.clear();
-
-            let fork_genesis_infos = self.genesis.fork_genesis_account_infos.lock();
-            for (address, info) in
-                self.genesis.accounts.iter().copied().zip(fork_genesis_infos.iter().cloned())
-            {
-                db.insert_account(address, info);
-            }
-
-            // reset the genesis.json alloc
-            self.genesis.apply_genesis_json_alloc(db)?;
+            self.apply_genesis().await?;
 
             Ok(())
         } else {

crates/anvil/tests/it/fork.rs

@@ -4,7 +4,7 @@ use crate::{
     abi::{Greeter, ERC721},
     utils::{http_provider, http_provider_with_signer},
 };
-use alloy_network::{EthereumWallet, TransactionBuilder};
+use alloy_network::{EthereumWallet, ReceiptResponse, TransactionBuilder};
 use alloy_primitives::{address, bytes, Address, Bytes, TxHash, TxKind, U256};
 use alloy_provider::Provider;
 use alloy_rpc_types::{
@@ -1301,3 +1301,45 @@ async fn test_fork_query_at_fork_block() {
 
     assert_eq!(balance_before, balance);
 }
+
+// <https://github.com/foundry-rs/foundry/issues/4173>
+#[tokio::test(flavor = "multi_thread")]
+async fn test_reset_dev_account_nonce() {
+    let config: NodeConfig = fork_config();
+    let address = config.genesis_accounts[0].address();
+    let (api, handle) = spawn(config).await;
+    let provider = handle.http_provider();
+    let info = api.anvil_node_info().await.unwrap();
+    let number = info.fork_config.fork_block_number.unwrap();
+    assert_eq!(number, BLOCK_NUMBER);
+
+    let nonce_before = provider.get_transaction_count(address).await.unwrap();
+
+    // Reset to older block with other nonce
+    api.anvil_reset(Some(Forking {
+        json_rpc_url: None,
+        block_number: Some(BLOCK_NUMBER - 1_000_000),
+    }))
+    .await
+    .unwrap();
+
+    let nonce_after = provider.get_transaction_count(address).await.unwrap();
+
+    assert!(nonce_before > nonce_after);
+
+    let receipt = provider
+        .send_transaction(WithOtherFields::new(
+            TransactionRequest::default()
+                .from(address)
+                .to(address)
+                .nonce(nonce_after)
+                .gas_limit(21000u128),
+        ))
+        .await
+        .unwrap()
+        .get_receipt()
+        .await
+        .unwrap();
+
+    assert!(receipt.status());
+}

crates/evm/core/src/backend/error.rs

@@ -14,7 +14,7 @@ pub enum BackendError {
     #[error("cheatcodes are not enabled for {0}; see `vm.allowCheatcodes(address)`")]
     NoCheats(Address),
     #[error(transparent)]
-    Backend(#[from] DatabaseError),
+    Database(#[from] DatabaseError),
     #[error("failed to fetch account info for {0}")]
     MissingAccount(Address),
     #[error(