refactor: rename

src/db/builder.rs

@@ -11,7 +11,7 @@ use revm::{
 };
 use std::collections::BTreeMap;
 
-use super::{ConcurrentCacheState, ConcurrentStateCache};
+use super::{ConcurrentCacheState, ConcurrentStateInfo};
 
 /// Allows building of State and initializing it with different options.
 #[derive(Clone, Debug)]
@@ -150,7 +150,7 @@ impl<DB: DatabaseRef> ConcurrentStateBuilder<DB> {
         };
         ConcurrentState::new(
             self.database,
-            ConcurrentStateCache {
+            ConcurrentStateInfo {
                 cache: self
                     .with_cache_prestate
                     .unwrap_or_else(|| ConcurrentCacheState::new(self.with_state_clear)),

src/db/mod.rs

@@ -5,7 +5,7 @@ mod cache_state;
 pub use cache_state::ConcurrentCacheState;
 
 mod sync_state;
-pub use sync_state::{ConcurrentState, ConcurrentStateCache};
+pub use sync_state::{ConcurrentState, ConcurrentStateInfo};
 
 use crate::{EvmNeedsBlock, Trevm};
 use revm::{

src/db/sync_state.rs

@@ -19,7 +19,7 @@ use std::{collections::hash_map, sync::RwLock};
 pub struct ConcurrentState<Db> {
     database: Db,
     /// Non-DB state cache and transition information.
-    pub info: ConcurrentStateCache,
+    pub info: ConcurrentStateInfo,
 }
 
 impl<Db> From<State<Db>> for ConcurrentState<Db>
@@ -29,7 +29,7 @@ where
     fn from(value: State<Db>) -> Self {
         Self {
             database: value.database,
-            info: ConcurrentStateCache {
+            info: ConcurrentStateInfo {
                 cache: value.cache.into(),
                 transition_state: value.transition_state,
                 bundle_state: value.bundle_state,
@@ -42,7 +42,7 @@ where
 
 /// Non-DB contents of [`ConcurrentState`]
 #[derive(Debug, Default)]
-pub struct ConcurrentStateCache {
+pub struct ConcurrentStateInfo {
     /// Cached state contains both changed from evm execution and cached/loaded
     /// account/storages from database. This allows us to have only one layer
     /// of cache where we can fetch data. Additionally we can introduce some
@@ -75,12 +75,12 @@ pub struct ConcurrentStateCache {
 impl<Db: DatabaseRef> ConcurrentState<Db> {
     /// Create a new [`ConcurrentState`] with the given database and cache
     /// state.
-    pub const fn new(database: Db, info: ConcurrentStateCache) -> Self {
+    pub const fn new(database: Db, info: ConcurrentStateInfo) -> Self {
         Self { database, info }
     }
 
     /// Deconstruct the [`ConcurrentState`] into its parts.
-    pub fn into_parts(self) -> (Db, ConcurrentStateCache) {
+    pub fn into_parts(self) -> (Db, ConcurrentStateInfo) {
         (self.database, self.info)
     }