feat: support eip-7610

crates/primitives/src/db.rs

@@ -18,6 +18,9 @@ pub trait Database {
     /// Get account code by its hash.
     fn code_by_hash(&mut self, code_hash: B256) -> Result<Bytecode, Self::Error>;
 
+    /// Get if the account already has storage (to support EIP-7610)
+    fn has_storage(&mut self, address: Address) -> Result<bool, Self::Error>;
+
     /// Get storage value of address at index.
     fn storage(&mut self, address: Address, index: U256) -> Result<U256, Self::Error>;
 
@@ -49,6 +52,9 @@ pub trait DatabaseRef {
     /// Get account code by its hash.
     fn code_by_hash_ref(&self, code_hash: B256) -> Result<Bytecode, Self::Error>;
 
+    /// Get if the account already has storage (to support EIP-7610)
+    fn has_storage_ref(&self, address: Address) -> Result<bool, Self::Error>;
+
     /// Get storage value of address at index.
     fn storage_ref(&self, address: Address, index: U256) -> Result<U256, Self::Error>;
 
@@ -85,6 +91,11 @@ impl<T: DatabaseRef> Database for WrapDatabaseRef<T> {
         self.0.storage_ref(address, index)
     }
 
+    #[inline]
+    fn has_storage(&mut self, address: Address) -> Result<bool, Self::Error> {
+        self.0.has_storage_ref(address)
+    }
+
     #[inline]
     fn block_hash(&mut self, number: u64) -> Result<B256, Self::Error> {
         self.0.block_hash_ref(number)

crates/primitives/src/db/components.rs

@@ -37,6 +37,10 @@ impl<S: State, BH: BlockHash> Database for DatabaseComponents<S, BH> {
             .map_err(Self::Error::State)
     }
 
+    fn has_storage(&mut self, address: Address) -> Result<bool, Self::Error> {
+        self.state.has_storage(address).map_err(Self::Error::State)
+    }
+
     fn storage(&mut self, address: Address, index: U256) -> Result<U256, Self::Error> {
         self.state
             .storage(address, index)
@@ -63,6 +67,10 @@ impl<S: StateRef, BH: BlockHashRef> DatabaseRef for DatabaseComponents<S, BH> {
             .map_err(Self::Error::State)
     }
 
+    fn has_storage_ref(&self, address: Address) -> Result<bool, Self::Error> {
+        self.state.has_storage(address).map_err(Self::Error::State)
+    }
+
     fn storage_ref(&self, address: Address, index: U256) -> Result<U256, Self::Error> {
         self.state
             .storage(address, index)

crates/primitives/src/db/components/state.rs

@@ -16,6 +16,9 @@ pub trait State {
     /// Get account code by its hash
     fn code_by_hash(&mut self, code_hash: B256) -> Result<Bytecode, Self::Error>;
 
+    /// Get if the account already has storage (to support EIP-7610)
+    fn has_storage(&mut self, address: Address) -> Result<bool, Self::Error>;
+
     /// Get storage value of address at index.
     fn storage(&mut self, address: Address, index: U256) -> Result<U256, Self::Error>;
 }
@@ -30,6 +33,9 @@ pub trait StateRef {
     /// Get account code by its hash
     fn code_by_hash(&self, code_hash: B256) -> Result<Bytecode, Self::Error>;
 
+    /// Get if the account already has storage (to support EIP-7610)
+    fn has_storage(&self, address: Address) -> Result<bool, Self::Error>;
+
     /// Get storage value of address at index.
     fn storage(&self, address: Address, index: U256) -> Result<U256, Self::Error>;
 }
@@ -48,6 +54,10 @@ where
         StateRef::code_by_hash(*self, code_hash)
     }
 
+    fn has_storage(&mut self, address: Address) -> Result<bool, Self::Error> {
+        StateRef::has_storage(*self, address)
+    }
+
     fn storage(&mut self, address: Address, index: U256) -> Result<U256, Self::Error> {
         StateRef::storage(*self, address, index)
     }
@@ -67,6 +77,10 @@ where
         self.deref().code_by_hash(code_hash)
     }
 
+    fn has_storage(&mut self, address: Address) -> Result<bool, Self::Error> {
+        self.deref().has_storage(address)
+    }
+
     fn storage(&mut self, address: Address, index: U256) -> Result<U256, Self::Error> {
         self.deref().storage(address, index)
     }

crates/revm/src/context/evm_context.rs

@@ -309,10 +309,17 @@ impl<DB: Database> EvmContext<DB> {
         // warm load account.
         self.load_account(created_address)?;
 
+        // This only check with the pre-execution state. Can storage be cleared after load?
+        let address_has_storage = self
+            .db
+            .has_storage(created_address)
+            .map_err(EVMError::Database)?;
+
         // create account, transfer funds and make the journal checkpoint.
         let checkpoint = match self.journaled_state.create_account_checkpoint(
             inputs.caller,
             created_address,
+            address_has_storage,
             inputs.value,
             spec_id,
         ) {
@@ -421,10 +428,17 @@ impl<DB: Database> EvmContext<DB> {
         // Load account so it needs to be marked as warm for access list.
         self.load_account(created_address)?;
 
+        // This only check with the pre-execution state. Can storage be cleared after load?
+        let address_has_storage = self
+            .db
+            .has_storage(created_address)
+            .map_err(EVMError::Database)?;
+
         // create account, transfer funds and make the journal checkpoint.
         let checkpoint = match self.journaled_state.create_account_checkpoint(
             inputs.caller,
             created_address,
+            address_has_storage,
             inputs.value,
             spec_id,
         ) {

crates/revm/src/db/alloydb.rs

@@ -137,6 +137,11 @@ impl<T: Transport + Clone, N: Network, P: Provider<T, N>> DatabaseRef for AlloyD
         // This is not needed, as the code is already loaded with basic_ref
     }
 
+    fn has_storage_ref(&self, _address: Address) -> Result<bool, Self::Error> {
+        // FIXME
+        Ok(false)
+    }
+
     fn storage_ref(&self, address: Address, index: U256) -> Result<U256, Self::Error> {
         let f = self
             .provider
@@ -151,7 +156,7 @@ impl<T: Transport + Clone, N: Network, P: Provider<T, N>> Database for AlloyDB<T
     type Error = TransportError;
 
     #[inline]
-    fn basic(&mut self, address: Address) -> Result<Option<AccountInfo>, Self::Error> {
+    fn basic(&mut self, address: Address, _: bool) -> Result<Option<AccountInfo>, Self::Error> {
         <Self as DatabaseRef>::basic_ref(self, address)
     }
 
@@ -160,6 +165,11 @@ impl<T: Transport + Clone, N: Network, P: Provider<T, N>> Database for AlloyDB<T
         <Self as DatabaseRef>::code_by_hash_ref(self, code_hash)
     }
 
+    #[inline]
+    fn has_storage(&mut self, address: Address) -> Result<bool, Self::Error> {
+        <Self as DatabaseRef>::has_storage_ref(self, address)
+    }
+
     #[inline]
     fn storage(&mut self, address: Address, index: U256) -> Result<U256, Self::Error> {
         <Self as DatabaseRef>::storage_ref(self, address, index)

crates/revm/src/db/emptydb.rs

@@ -66,6 +66,11 @@ impl<E> Database for EmptyDBTyped<E> {
         <Self as DatabaseRef>::code_by_hash_ref(self, code_hash)
     }
 
+    #[inline]
+    fn has_storage(&mut self, address: Address) -> Result<bool, Self::Error> {
+        <Self as DatabaseRef>::has_storage_ref(self, address)
+    }
+
     #[inline]
     fn storage(&mut self, address: Address, index: U256) -> Result<U256, Self::Error> {
         <Self as DatabaseRef>::storage_ref(self, address, index)
@@ -90,6 +95,11 @@ impl<E> DatabaseRef for EmptyDBTyped<E> {
         Ok(Bytecode::default())
     }
 
+    #[inline]
+    fn has_storage_ref(&self, _address: Address) -> Result<bool, Self::Error> {
+        Ok(false)
+    }
+
     #[inline]
     fn storage_ref(&self, _address: Address, _index: U256) -> Result<U256, Self::Error> {
         Ok(U256::default())

crates/revm/src/db/ethersdb.rs

@@ -135,6 +135,10 @@ impl<M: Middleware> DatabaseRef for EthersDB<M> {
         // not needed because we already load code with basic info
     }
 
+    fn has_storage_ref(&self, _address: Address) -> Result<bool, Self::Error> {
+        todo!()
+    }
+
     fn storage_ref(&self, address: Address, index: U256) -> Result<U256, Self::Error> {
         let add = eH160::from(address.0 .0);
         let index = H256::from(index.to_be_bytes());
@@ -165,6 +169,11 @@ impl<M: Middleware> Database for EthersDB<M> {
         <Self as DatabaseRef>::code_by_hash_ref(self, code_hash)
     }
 
+    #[inline]
+    fn has_storage(&mut self, address: Address) -> Result<bool, Self::Error> {
+        <Self as DatabaseRef>::has_storage_ref(self, address)
+    }
+
     #[inline]
     fn storage(&mut self, address: Address, index: U256) -> Result<U256, Self::Error> {
         <Self as DatabaseRef>::storage_ref(self, address, index)

crates/revm/src/db/in_memory_db.rs

@@ -194,6 +194,13 @@ impl<ExtDB: DatabaseRef> Database for CacheDB<ExtDB> {
         }
     }
 
+    fn has_storage(&mut self, address: Address) -> Result<bool, Self::Error> {
+        Ok(match self.accounts.get(&address) {
+            Some(account) => !account.storage.is_empty(),
+            _ => false,
+        })
+    }
+
     /// Get the value in an account's storage slot.
     ///
     /// It is assumed that account is already loaded.
@@ -263,6 +270,13 @@ impl<ExtDB: DatabaseRef> DatabaseRef for CacheDB<ExtDB> {
         }
     }
 
+    fn has_storage_ref(&self, address: Address) -> Result<bool, Self::Error> {
+        Ok(match self.accounts.get(&address) {
+            Some(account) => !account.storage.is_empty(),
+            _ => false,
+        })
+    }
+
     fn storage_ref(&self, address: Address, index: U256) -> Result<U256, Self::Error> {
         match self.accounts.get(&address) {
             Some(acc_entry) => match acc_entry.storage.get(&index) {
@@ -397,6 +411,10 @@ impl Database for BenchmarkDB {
         Ok(Bytecode::default())
     }
 
+    fn has_storage(&mut self, _address: Address) -> Result<bool, Self::Error> {
+        Ok(false)
+    }
+
     /// Get storage value of address at index.
     fn storage(&mut self, _address: Address, _index: U256) -> Result<U256, Self::Error> {
         Ok(U256::default())

crates/revm/src/db/states/state.rs

@@ -238,6 +238,20 @@ impl<DB: Database> Database for State<DB> {
         res
     }
 
+    fn has_storage(&mut self, address: Address) -> Result<bool, Self::Error> {
+        Ok(
+            match self
+                .cache
+                .accounts
+                .get(&address)
+                .and_then(|account| account.account.clone())
+            {
+                Some(account) => !account.storage.is_empty(),
+                _ => false,
+            },
+        )
+    }
+
     fn storage(&mut self, address: Address, index: U256) -> Result<U256, Self::Error> {
         // Account is guaranteed to be loaded.
         // Note that storage from bundle is already loaded with account.

crates/revm/src/journaled_state.rs

@@ -251,6 +251,7 @@ impl JournaledState {
         &mut self,
         caller: Address,
         address: Address,
+        address_has_storage: bool,
         balance: U256,
         spec_id: SpecId,
     ) -> Result<JournalCheckpoint, InstructionResult> {
@@ -261,11 +262,17 @@ impl JournaledState {
         let account = self.state.get_mut(&address).unwrap();
         let last_journal = self.journal.last_mut().unwrap();
 
-        // New account can be created if:
+        // New account cannot be created if:
         // Bytecode is not empty.
         // Nonce is not zero
-        // Account is not precompile.
-        if account.info.code_hash != KECCAK_EMPTY || account.info.nonce != 0 {
+        // Account is precompile.
+        // EIP-7610: Storage is not empty.
+        if account.info.code_hash != KECCAK_EMPTY
+            || account.info.nonce != 0
+            || self.warm_preloaded_addresses.contains(&address)
+            // Do we enable this check only for some `spec_id`?
+            || address_has_storage
+        {
             self.checkpoint_revert(checkpoint);
             return Err(InstructionResult::CreateCollision);
         }