feat(anvil): reset to in-mem (#10897)

* feat(`anvil`): reset to in-mem

* fmt + clippy

Author: yash-atreya

crates/anvil/src/eth/api.rs

@@ -1900,13 +1900,15 @@ impl EthApi {
     ///
     /// Handler for RPC call: `anvil_reset`
     pub async fn anvil_reset(&self, forking: Option<Forking>) -> Result<()> {
+        self.reset_instance_id();
         node_info!("anvil_reset");
         if let Some(forking) = forking {
             // if we're resetting the fork we need to reset the instance id
-            self.reset_instance_id();
             self.backend.reset_fork(forking).await
         } else {
-            Err(BlockchainError::RpcUnimplemented)
+            // Reset to a fresh in-memory state
+
+            self.backend.reset_to_in_mem().await
         }
     }
 

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

@@ -614,6 +614,54 @@ impl Backend {
         }
     }
 
+    /// Resets the backend to a fresh in-memory state, clearing all existing data
+    pub async fn reset_to_in_mem(&self) -> Result<(), BlockchainError> {
+        // Clear the fork if any exists
+        *self.fork.write() = None;
+
+        // Get environment and genesis config
+        let env = self.env.read().clone();
+        let genesis_timestamp = self.genesis.timestamp;
+        let genesis_number = self.genesis.number;
+        let spec_id = self.spec_id();
+
+        // Reset environment to genesis state
+        {
+            let mut env = self.env.write();
+            env.evm_env.block_env.number = genesis_number;
+            env.evm_env.block_env.timestamp = genesis_timestamp;
+            // Reset other block env fields to their defaults
+            env.evm_env.block_env.basefee = self.fees.base_fee();
+            env.evm_env.block_env.prevrandao = Some(B256::ZERO);
+        }
+
+        // Clear all storage and reinitialize with genesis
+        let base_fee = if self.fees.is_eip1559() { Some(self.fees.base_fee()) } else { None };
+        *self.blockchain.storage.write() =
+            BlockchainStorage::new(&env, spec_id, base_fee, genesis_timestamp, genesis_number);
+        self.states.write().clear();
+
+        // Clear the database
+        self.db.write().await.clear();
+
+        // Reset time manager
+        self.time.reset(genesis_timestamp);
+
+        // Reset fees to initial state
+        if self.fees.is_eip1559() {
+            self.fees.set_base_fee(crate::eth::fees::INITIAL_BASE_FEE);
+        }
+
+        self.fees.set_gas_price(crate::eth::fees::INITIAL_GAS_PRICE);
+
+        // Reapply genesis configuration
+        self.apply_genesis().await?;
+
+        trace!(target: "backend", "reset to fresh in-memory state");
+
+        Ok(())
+    }
+
     async fn reset_block_number(
         &self,
         fork_url: String,

crates/anvil/tests/it/anvil_api.rs

@@ -1055,3 +1055,95 @@ async fn test_mine_first_block_with_interval() {
     let second_block = api.block_by_number(2.into()).await.unwrap().unwrap();
     assert_eq!(second_block.header.timestamp, init_timestamp + 120);
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_anvil_reset_non_fork() {
+    let (api, handle) = spawn(NodeConfig::test()).await;
+    let provider = handle.http_provider();
+
+    // Get initial state
+    let init_block = provider.get_block(BlockId::latest()).await.unwrap().unwrap();
+    let init_accounts = api.accounts().unwrap();
+    let init_balance = provider.get_balance(init_accounts[0]).await.unwrap();
+
+    // Store the instance id before reset
+    let instance_id_before = api.instance_id();
+
+    // Mine some blocks and make transactions
+    for _ in 0..5 {
+        api.mine_one().await;
+    }
+
+    // Send a transaction
+    let to = Address::random();
+    let val = U256::from(1337);
+    let tx = TransactionRequest::default().with_from(init_accounts[0]).with_to(to).with_value(val);
+    let tx = WithOtherFields::new(tx);
+
+    let _ = provider.send_transaction(tx).await.unwrap().get_receipt().await.unwrap();
+
+    // Check state has changed
+    let block_before_reset = provider.get_block(BlockId::latest()).await.unwrap().unwrap();
+    assert!(block_before_reset.header.number > init_block.header.number);
+
+    let balance_before_reset = provider.get_balance(init_accounts[0]).await.unwrap();
+    assert!(balance_before_reset < init_balance);
+
+    let to_balance_before_reset = provider.get_balance(to).await.unwrap();
+    assert_eq!(to_balance_before_reset, val);
+
+    // Reset to fresh in-memory state (non-fork)
+    api.anvil_reset(None).await.unwrap();
+
+    // Check instance id has changed
+    let instance_id_after = api.instance_id();
+    assert_ne!(instance_id_before, instance_id_after);
+
+    // Check we're back at genesis
+    let block_after_reset = provider.get_block(BlockId::latest()).await.unwrap().unwrap();
+    assert_eq!(block_after_reset.header.number, 0);
+
+    // Check accounts are restored to initial state
+    let balance_after_reset = provider.get_balance(init_accounts[0]).await.unwrap();
+    assert_eq!(balance_after_reset, init_balance);
+
+    // Check the recipient's balance is zero
+    let to_balance_after_reset = provider.get_balance(to).await.unwrap();
+    assert_eq!(to_balance_after_reset, U256::ZERO);
+
+    // Test we can continue mining after reset
+    api.mine_one().await;
+    let new_block = provider.get_block(BlockId::latest()).await.unwrap().unwrap();
+    assert_eq!(new_block.header.number, 1);
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_anvil_reset_fork_to_non_fork() {
+    let (api, handle) = spawn(fork_config()).await;
+    let provider = handle.http_provider();
+
+    // Verify we're in fork mode
+    let metadata = api.anvil_metadata().await.unwrap();
+    assert!(metadata.forked_network.is_some());
+
+    // Mine some blocks
+    for _ in 0..3 {
+        api.mine_one().await;
+    }
+
+    // Reset to non-fork mode
+    api.anvil_reset(None).await.unwrap();
+
+    // Verify we're no longer in fork mode
+    let metadata_after = api.anvil_metadata().await.unwrap();
+    assert!(metadata_after.forked_network.is_none());
+
+    // Check we're at block 0
+    let block = provider.get_block(BlockId::latest()).await.unwrap().unwrap();
+    assert_eq!(block.header.number, 0);
+
+    // Verify we can still mine blocks
+    api.mine_one().await;
+    let new_block = provider.get_block(BlockId::latest()).await.unwrap().unwrap();
+    assert_eq!(new_block.header.number, 1);
+}