fix(anvil): load account first before setting storage (#2699)

* test: add bsc test

* fix: cache account issue

Author: mattsse

anvil/src/eth/backend/mem/fork_db.rs

@@ -4,6 +4,7 @@ use crate::{
     Address, U256,
 };
 use ethers::prelude::H256;
+use forge::revm::Database;
 use foundry_evm::executor::fork::database::ForkDbSnapshot;
 pub use foundry_evm::executor::fork::database::ForkedDatabase;
 
@@ -14,6 +15,8 @@ impl Db for ForkedDatabase {
     }
 
     fn set_storage_at(&mut self, address: Address, slot: U256, val: U256) {
+        // this ensures the account is loaded first
+        let _ = Database::basic(self, address);
         self.database_mut().set_storage_at(address, slot, val)
     }
 

anvil/tests/it/abi.rs

@@ -39,3 +39,9 @@ abigen!(
             _exists(uint256)(bool)
 ]"#
 );
+abigen!(
+    BUSD,
+    r#"[
+            balanceOf(address)(uint256)
+]"#
+);

anvil/tests/it/anvil_api.rs

@@ -3,9 +3,10 @@ use crate::{abi::*, fork::fork_config};
 use anvil::{spawn, Hardfork, NodeConfig};
 use anvil_core::eth::EthRequest;
 use ethers::{
-    abi::ethereum_types::BigEndianHash,
+    abi::{ethereum_types::BigEndianHash, AbiDecode},
     prelude::{Middleware, SignerMiddleware},
     types::{Address, BlockNumber, TransactionRequest, H256, U256},
+    utils::hex,
 };
 use std::{
     sync::Arc,
@@ -237,3 +238,31 @@ async fn test_timestamp_interval() {
     // check interval is disabled
     assert!(another_block.timestamp - new_block.timestamp < U256::from(interval));
 }
+
+// <https://github.com/foundry-rs/foundry/issues/2341>
+#[tokio::test(flavor = "multi_thread")]
+async fn test_can_set_storage_bsc_fork() {
+    let (api, handle) =
+        spawn(NodeConfig::test().with_eth_rpc_url(Some("https://bsc-dataseed.binance.org/"))).await;
+    let provider = Arc::new(handle.http_provider());
+
+    let busd_addr: Address = "0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56".parse().unwrap();
+    let idx: U256 =
+        "0xa6eef7e35abe7026729641147f7915573c7e97b47efa546f5f6e3230263bcb49".parse().unwrap();
+    let value: H256 =
+        "0x0000000000000000000000000000000000000000000000000000000000003039".parse().unwrap();
+
+    api.anvil_set_storage_at(busd_addr, idx, value).await.unwrap();
+    let storage = api.storage_at(busd_addr, idx, None).await.unwrap();
+    assert_eq!(storage, value);
+
+    let input =
+        hex::decode("70a082310000000000000000000000000000000000000000000000000000000000000000")
+            .unwrap();
+
+    let busd = BUSD::new(busd_addr, provider);
+    let call = busd::BalanceOfCall::decode(&input).unwrap();
+
+    let balance = busd.balance_of(call.0).call().await.unwrap();
+    assert_eq!(balance, U256::from(12345u64));
+}

evm/src/executor/fork/database.rs

@@ -141,19 +141,19 @@ impl ForkedDatabase {
 
 impl Database for ForkedDatabase {
     fn basic(&mut self, address: Address) -> AccountInfo {
-        self.cache_db.basic(address)
+        Database::basic(&mut self.cache_db, address)
     }
 
     fn code_by_hash(&mut self, code_hash: H256) -> Bytecode {
-        self.cache_db.code_by_hash(code_hash)
+        Database::code_by_hash(&mut self.cache_db, code_hash)
     }
 
     fn storage(&mut self, address: Address, index: U256) -> U256 {
         Database::storage(&mut self.cache_db, address, index)
     }
 
     fn block_hash(&mut self, number: U256) -> H256 {
-        self.cache_db.block_hash(number)
+        Database::block_hash(&mut self.cache_db, number)
     }
 }