diff --git a/bins/revme/src/cmd/blockchaintest.rs b/bins/revme/src/cmd/blockchaintest.rs
index 44503babb6..c701e95d2e 100644
--- a/bins/revme/src/cmd/blockchaintest.rs
+++ b/bins/revme/src/cmd/blockchaintest.rs
@@ -14,7 +14,7 @@ use revm::{
     database::{states::bundle_state::BundleRetention, EmptyDB, State},
     handler::EvmTr,
     inspector::inspectors::TracerEip3155,
-    primitives::{hardfork::SpecId, hex, Address, HashMap, U256},
+    primitives::{hardfork::SpecId, hex, Address, AddressMap, U256Map, U256},
     state::{bal::Bal, AccountInfo},
     Context, Database, ExecuteCommitEvm, ExecuteEvm, InspectEvm, MainBuilder, MainContext,
 };
@@ -272,7 +272,7 @@ fn run_test_file(
 #[derive(Debug, Clone)]
 struct DebugInfo {
     /// Initial pre-state before any execution
-    pre_state: HashMap<Address, (AccountInfo, HashMap<U256, U256>)>,
+    pre_state: AddressMap<(AccountInfo, U256Map<U256>)>,
     /// Transaction environment
     tx_env: Option<revm::context::tx::TxEnv>,
     /// Block environment
@@ -289,15 +289,13 @@ struct DebugInfo {
 
 impl DebugInfo {
     /// Capture current state from the State database
-    fn capture_committed_state(
-        state: &State<EmptyDB>,
-    ) -> HashMap<Address, (AccountInfo, HashMap<U256, U256>)> {
-        let mut committed_state = HashMap::default();
+    fn capture_committed_state(state: &State<EmptyDB>) -> AddressMap<(AccountInfo, U256Map<U256>)> {
+        let mut committed_state = AddressMap::default();
 
         // Access the cache state to get all accounts
         for (address, cache_account) in &state.cache.accounts {
             if let Some(plain_account) = &cache_account.account {
-                let mut storage = HashMap::default();
+                let mut storage = U256Map::default();
                 for (key, value) in &plain_account.storage {
                     storage.insert(*key, *value);
                 }
@@ -668,7 +666,7 @@ fn execute_blockchain_test(
     let mut state = State::builder().with_bal_builder().build();
 
     // Capture pre-state for debug info
-    let mut pre_state_debug = HashMap::default();
+    let mut pre_state_debug = AddressMap::default();
 
     // Insert genesis state into database
     let genesis_state = test_case.pre.clone().into_genesis_state();
diff --git a/crates/context/interface/src/journaled_state.rs b/crates/context/interface/src/journaled_state.rs
index 33c085a705..0901d54f88 100644
--- a/crates/context/interface/src/journaled_state.rs
+++ b/crates/context/interface/src/journaled_state.rs
@@ -12,7 +12,8 @@ use crate::{
 use core::ops::{Deref, DerefMut};
 use database_interface::Database;
 use primitives::{
-    hardfork::SpecId, Address, Bytes, HashMap, HashSet, Log, StorageKey, StorageValue, B256, U256,
+    hardfork::SpecId, Address, AddressMap, AddressSet, Bytes, HashSet, Log, StorageKey,
+    StorageValue, B256, U256,
 };
 use state::{Account, AccountInfo, Bytecode};
 use std::{borrow::Cow, vec::Vec};
@@ -104,16 +105,16 @@ pub trait JournalTr {
     ) -> Result<StateLoad<SelfDestructResult>, JournalLoadError<<Self::Database as Database>::Error>>;
 
     /// Sets access list inside journal.
-    fn warm_access_list(&mut self, access_list: HashMap<Address, HashSet<StorageKey>>);
+    fn warm_access_list(&mut self, access_list: AddressMap<HashSet<StorageKey>>);
 
     /// Warms the coinbase account.
     fn warm_coinbase_account(&mut self, address: Address);
 
     /// Warms the precompiles.
-    fn warm_precompiles(&mut self, addresses: HashSet<Address>);
+    fn warm_precompiles(&mut self, addresses: AddressSet);
 
     /// Returns the addresses of the precompiles.
-    fn precompile_addresses(&self) -> &HashSet<Address>;
+    fn precompile_addresses(&self) -> &AddressSet;
 
     /// Sets the spec id.
     fn set_spec_id(&mut self, spec_id: SpecId);
diff --git a/crates/context/interface/src/journaled_state/account.rs b/crates/context/interface/src/journaled_state/account.rs
index 13c185502b..bdccf0aeb4 100644
--- a/crates/context/interface/src/journaled_state/account.rs
+++ b/crates/context/interface/src/journaled_state/account.rs
@@ -13,7 +13,8 @@ use super::entry::JournalEntryTr;
 use auto_impl::auto_impl;
 use database_interface::Database;
 use primitives::{
-    hash_map::Entry, Address, HashMap, HashSet, StorageKey, StorageValue, B256, KECCAK_EMPTY, U256,
+    hash_map::Entry, Address, AddressMap, HashSet, StorageKey, StorageValue, B256, KECCAK_EMPTY,
+    U256,
 };
 use state::{Account, Bytecode, EvmStorageSlot};
 use std::vec::Vec;
@@ -129,7 +130,7 @@ pub struct JournaledAccount<'a, DB, ENTRY: JournalEntryTr = JournalEntry> {
     /// Journal entries.
     journal_entries: &'a mut Vec<ENTRY>,
     /// Access list.
-    access_list: &'a HashMap<Address, HashSet<StorageKey>>,
+    access_list: &'a AddressMap<HashSet<StorageKey>>,
     /// Transaction ID.
     transaction_id: usize,
     /// Database used to load storage.
@@ -144,7 +145,7 @@ impl<'a, DB: Database, ENTRY: JournalEntryTr> JournaledAccount<'a, DB, ENTRY> {
         account: &'a mut Account,
         journal_entries: &'a mut Vec<ENTRY>,
         db: &'a mut DB,
-        access_list: &'a HashMap<Address, HashSet<StorageKey>>,
+        access_list: &'a AddressMap<HashSet<StorageKey>>,
         transaction_id: usize,
     ) -> Self {
         Self {
diff --git a/crates/context/src/journal.rs b/crates/context/src/journal.rs
index 6814627d10..ac9137a22f 100644
--- a/crates/context/src/journal.rs
+++ b/crates/context/src/journal.rs
@@ -19,7 +19,8 @@ use context_interface::{
 use core::ops::{Deref, DerefMut};
 use database_interface::Database;
 use primitives::{
-    hardfork::SpecId, Address, HashMap, HashSet, Log, StorageKey, StorageValue, B256, U256,
+    hardfork::SpecId, Address, AddressMap, AddressSet, HashSet, Log, StorageKey, StorageValue,
+    B256, U256,
 };
 use state::{Account, EvmState};
 use std::vec::Vec;
@@ -168,7 +169,7 @@ impl<DB: Database, ENTRY: JournalEntryTr> JournalTr for Journal<DB, ENTRY> {
     }
 
     #[inline]
-    fn warm_access_list(&mut self, access_list: HashMap<Address, HashSet<StorageKey>>) {
+    fn warm_access_list(&mut self, access_list: AddressMap<HashSet<StorageKey>>) {
         self.inner.warm_addresses.set_access_list(access_list);
     }
 
@@ -176,14 +177,14 @@ impl<DB: Database, ENTRY: JournalEntryTr> JournalTr for Journal<DB, ENTRY> {
         self.inner.warm_addresses.set_coinbase(address);
     }
 
-    fn warm_precompiles(&mut self, precompiles: HashSet<Address>) {
+    fn warm_precompiles(&mut self, precompiles: AddressSet) {
         self.inner
             .warm_addresses
             .set_precompile_addresses(precompiles);
     }
 
     #[inline]
-    fn precompile_addresses(&self) -> &HashSet<Address> {
+    fn precompile_addresses(&self) -> &AddressSet {
         self.inner.warm_addresses.precompiles()
     }
 
diff --git a/crates/context/src/journal/warm_addresses.rs b/crates/context/src/journal/warm_addresses.rs
index 27e5bce936..2c4e2dd5a9 100644
--- a/crates/context/src/journal/warm_addresses.rs
+++ b/crates/context/src/journal/warm_addresses.rs
@@ -4,7 +4,9 @@
 
 use bitvec::{bitvec, vec::BitVec};
 use context_interface::journaled_state::JournalLoadError;
-use primitives::{short_address, Address, HashMap, HashSet, StorageKey, SHORT_ADDRESS_CAP};
+use primitives::{
+    short_address, Address, AddressMap, AddressSet, HashSet, StorageKey, SHORT_ADDRESS_CAP,
+};
 
 /// Stores addresses that are warm loaded. Contains precompiles and coinbase address.
 ///
@@ -19,7 +21,7 @@ use primitives::{short_address, Address, HashMap, HashSet, StorageKey, SHORT_ADD
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct WarmAddresses {
     /// Set of warm loaded precompile addresses.
-    precompile_set: HashSet<Address>,
+    precompile_set: AddressSet,
     /// Bit vector of precompile short addresses. If address is shorter than [`SHORT_ADDRESS_CAP`] it
     /// will be stored in this bit vector for faster access.
     precompile_short_addresses: BitVec,
@@ -28,7 +30,7 @@ pub struct WarmAddresses {
     /// Coinbase address.
     coinbase: Option<Address>,
     /// Access list
-    access_list: HashMap<Address, HashSet<StorageKey>>,
+    access_list: AddressMap<HashSet<StorageKey>>,
 }
 
 impl Default for WarmAddresses {
@@ -42,17 +44,17 @@ impl WarmAddresses {
     #[inline]
     pub fn new() -> Self {
         Self {
-            precompile_set: HashSet::default(),
+            precompile_set: AddressSet::default(),
             precompile_short_addresses: bitvec![0; SHORT_ADDRESS_CAP],
             precompile_all_short_addresses: true,
             coinbase: None,
-            access_list: HashMap::default(),
+            access_list: AddressMap::default(),
         }
     }
 
     /// Returns the precompile addresses.
     #[inline]
-    pub fn precompiles(&self) -> &HashSet<Address> {
+    pub fn precompiles(&self) -> &AddressSet {
         &self.precompile_set
     }
 
@@ -64,7 +66,7 @@ impl WarmAddresses {
 
     /// Set the precompile addresses and short addresses.
     #[inline]
-    pub fn set_precompile_addresses(&mut self, addresses: HashSet<Address>) {
+    pub fn set_precompile_addresses(&mut self, addresses: AddressSet) {
         self.precompile_short_addresses.fill(false);
 
         let mut all_short_addresses = true;
@@ -88,13 +90,13 @@ impl WarmAddresses {
 
     /// Set the access list.
     #[inline]
-    pub fn set_access_list(&mut self, access_list: HashMap<Address, HashSet<StorageKey>>) {
+    pub fn set_access_list(&mut self, access_list: AddressMap<HashSet<StorageKey>>) {
         self.access_list = access_list;
     }
 
     /// Returns the access list.
     #[inline]
-    pub fn access_list(&self) -> &HashMap<Address, HashSet<StorageKey>> {
+    pub fn access_list(&self) -> &AddressMap<HashSet<StorageKey>> {
         &self.access_list
     }
 
diff --git a/crates/database/interface/src/either.rs b/crates/database/interface/src/either.rs
index ce1e7d1336..aef10dab89 100644
--- a/crates/database/interface/src/either.rs
+++ b/crates/database/interface/src/either.rs
@@ -2,7 +2,7 @@
 
 use crate::{Database, DatabaseCommit, DatabaseRef};
 use either::Either;
-use primitives::{Address, HashMap, StorageKey, StorageValue, B256};
+use primitives::{Address, AddressMap, StorageKey, StorageValue, B256};
 use state::{Account, AccountInfo, Bytecode};
 
 impl<L, R> Database for Either<L, R>
@@ -62,7 +62,7 @@ where
     L: DatabaseCommit,
     R: DatabaseCommit,
 {
-    fn commit(&mut self, changes: HashMap<Address, Account>) {
+    fn commit(&mut self, changes: AddressMap<Account>) {
         match self {
             Self::Left(db) => db.commit(changes),
             Self::Right(db) => db.commit(changes),
diff --git a/crates/database/interface/src/lib.rs b/crates/database/interface/src/lib.rs
index 140d0298ef..c0e24fd920 100644
--- a/crates/database/interface/src/lib.rs
+++ b/crates/database/interface/src/lib.rs
@@ -8,7 +8,7 @@ extern crate alloc as std;
 use core::convert::Infallible;
 
 use auto_impl::auto_impl;
-use primitives::{address, Address, HashMap, StorageKey, StorageValue, B256, U256};
+use primitives::{address, Address, AddressMap, StorageKey, StorageValue, B256, U256};
 use state::{Account, AccountInfo, Bytecode};
 use std::vec::Vec;
 
@@ -92,13 +92,13 @@ pub trait Database {
 #[auto_impl(&mut, Box)]
 pub trait DatabaseCommit {
     /// Commit changes to the database.
-    fn commit(&mut self, changes: HashMap<Address, Account>);
+    fn commit(&mut self, changes: AddressMap<Account>);
 
     /// Commit changes to the database with an iterator.
     ///
     /// Implementors of [`DatabaseCommit`] should override this method when possible for efficiency.
     ///
-    /// Callers should prefer using [`DatabaseCommit::commit`] when they already have a [`HashMap`].
+    /// Callers should prefer using [`DatabaseCommit::commit`] when they already have a [`AddressMap`].
     ///
     /// # Dyn Compatibility
     ///
@@ -106,7 +106,7 @@ pub trait DatabaseCommit {
     /// For ergonomic usage with `impl IntoIterator`, use the inherent method
     /// `commit_from_iter` on `dyn DatabaseCommit`.
     fn commit_iter(&mut self, changes: &mut dyn Iterator<Item = (Address, Account)>) {
-        let changes: HashMap<Address, Account> = changes.collect();
+        let changes: AddressMap<Account> = changes.collect();
         self.commit(changes);
     }
 }
@@ -206,7 +206,7 @@ impl<T: DatabaseRef> Database for WrapDatabaseRef<T> {
 
 impl<T: DatabaseRef + DatabaseCommit> DatabaseCommit for WrapDatabaseRef<T> {
     #[inline]
-    fn commit(&mut self, changes: HashMap<Address, Account>) {
+    fn commit(&mut self, changes: AddressMap<Account>) {
         self.0.commit(changes)
     }
 }
@@ -321,7 +321,7 @@ mod tests {
         }
 
         impl DatabaseCommit for MockDb {
-            fn commit(&mut self, changes: HashMap<Address, Account>) {
+            fn commit(&mut self, changes: AddressMap<Account>) {
                 let std_map: StdHashMap<_, _> = changes.into_iter().collect();
                 self.commits.push(std_map);
             }
@@ -337,7 +337,7 @@ mod tests {
         // Test commit() on trait objects
         {
             let db_dyn: &mut dyn DatabaseCommit = &mut db;
-            db_dyn.commit(HashMap::default());
+            db_dyn.commit(AddressMap::default());
         }
         assert_eq!(db.commits.len(), 2);
 
diff --git a/crates/database/interface/src/try_commit.rs b/crates/database/interface/src/try_commit.rs
index 71595d186b..65fd487183 100644
--- a/crates/database/interface/src/try_commit.rs
+++ b/crates/database/interface/src/try_commit.rs
@@ -1,7 +1,7 @@
 //! Try database commit interface.
 use crate::DatabaseCommit;
 use core::{convert::Infallible, error::Error, fmt};
-use primitives::{Address, HashMap};
+use primitives::AddressMap;
 use state::Account;
 use std::sync::Arc;
 
@@ -15,7 +15,7 @@ pub trait TryDatabaseCommit {
     type Error: Error;
 
     /// Attempt to commit changes to the database.
-    fn try_commit(&mut self, changes: HashMap<Address, Account>) -> Result<(), Self::Error>;
+    fn try_commit(&mut self, changes: AddressMap<Account>) -> Result<(), Self::Error>;
 }
 
 impl<Db> TryDatabaseCommit for Db
@@ -25,7 +25,7 @@ where
     type Error = Infallible;
 
     #[inline]
-    fn try_commit(&mut self, changes: HashMap<Address, Account>) -> Result<(), Self::Error> {
+    fn try_commit(&mut self, changes: AddressMap<Account>) -> Result<(), Self::Error> {
         self.commit(changes);
         Ok(())
     }
@@ -51,7 +51,7 @@ where
     type Error = ArcUpgradeError;
 
     #[inline]
-    fn try_commit(&mut self, changes: HashMap<Address, Account>) -> Result<(), Self::Error> {
+    fn try_commit(&mut self, changes: AddressMap<Account>) -> Result<(), Self::Error> {
         Arc::get_mut(self)
             .map(|db| db.commit(changes))
             .ok_or(ArcUpgradeError)
@@ -67,7 +67,7 @@ mod test {
     struct MockDb;
 
     impl DatabaseCommit for MockDb {
-        fn commit(&mut self, _changes: HashMap<Address, Account>) {}
+        fn commit(&mut self, _changes: AddressMap<Account>) {}
     }
 
     #[test]
diff --git a/crates/database/src/in_memory_db.rs b/crates/database/src/in_memory_db.rs
index 16166853fe..841ad46b34 100644
--- a/crates/database/src/in_memory_db.rs
+++ b/crates/database/src/in_memory_db.rs
@@ -4,8 +4,8 @@ use database_interface::{
     BENCH_TARGET, BENCH_TARGET_BALANCE,
 };
 use primitives::{
-    hash_map::Entry, Address, AddressMap, B256Map, HashMap, Log, StorageKey, StorageValue, B256,
-    KECCAK_EMPTY, U256,
+    hash_map::Entry, Address, AddressMap, B256Map, HashMap, Log, StorageKey, StorageKeyMap,
+    StorageValue, U256Map, B256, KECCAK_EMPTY, U256,
 };
 use state::{Account, AccountInfo, Bytecode};
 use std::vec::Vec;
@@ -29,7 +29,7 @@ pub struct Cache {
     /// All logs that were committed via [DatabaseCommit::commit].
     pub logs: Vec<Log>,
     /// All cached block hashes from the [DatabaseRef].
-    pub block_hashes: HashMap<U256, B256>,
+    pub block_hashes: U256Map<B256>,
 }
 
 impl Default for Cache {
@@ -183,7 +183,7 @@ impl<ExtDB: DatabaseRef> CacheDB<ExtDB> {
     pub fn replace_account_storage(
         &mut self,
         address: Address,
-        storage: HashMap<StorageKey, StorageValue>,
+        storage: StorageKeyMap<StorageValue>,
     ) -> Result<(), ExtDB::Error> {
         let account = self.load_account(address)?;
         account.account_state = AccountState::StorageCleared;
@@ -280,7 +280,7 @@ impl<ExtDB: DatabaseRef> CacheDB<ExtDB> {
 }
 
 impl<ExtDB> DatabaseCommit for CacheDB<ExtDB> {
-    fn commit(&mut self, changes: HashMap<Address, Account>) {
+    fn commit(&mut self, changes: AddressMap<Account>) {
         for (address, mut account) in changes {
             if !account.is_touched() {
                 continue;
@@ -459,7 +459,7 @@ pub struct DbAccount {
     /// If account is selfdestructed or newly created, storage will be cleared.
     pub account_state: AccountState,
     /// Storage slots
-    pub storage: HashMap<StorageKey, StorageValue>,
+    pub storage: StorageKeyMap<StorageValue>,
 }
 
 impl DbAccount {
diff --git a/crates/database/src/states/bundle_account.rs b/crates/database/src/states/bundle_account.rs
index 54bd85ff10..2c1d8081ca 100644
--- a/crates/database/src/states/bundle_account.rs
+++ b/crates/database/src/states/bundle_account.rs
@@ -2,7 +2,7 @@ use super::{
     reverts::AccountInfoRevert, AccountRevert, AccountStatus, RevertToSlot, StorageSlot,
     StorageWithOriginalValues, TransitionAccount,
 };
-use primitives::{HashMap, StorageKey, StorageValue};
+use primitives::{HashMap, StorageKey, StorageKeyMap, StorageValue};
 use state::AccountInfo;
 
 /// Account information focused on creating of database changesets
@@ -152,7 +152,7 @@ impl BundleAccount {
             };
 
         let previous_storage_from_update =
-            |updated_storage: &StorageWithOriginalValues| -> HashMap<StorageKey, RevertToSlot> {
+            |updated_storage: &StorageWithOriginalValues| -> StorageKeyMap<RevertToSlot> {
                 updated_storage
                     .iter()
                     .filter(|s| s.1.is_changed())
@@ -288,7 +288,7 @@ impl BundleAccount {
                                 let mut storage = core::mem::take(&mut self.storage)
                                     .into_iter()
                                     .map(|t| (t.0, RevertToSlot::Some(t.1.present_value)))
-                                    .collect::<HashMap<_, _>>();
+                                    .collect::<StorageKeyMap<_>>();
                                 for key in updated_storage.keys() {
                                     // As it is not existing inside Destroyed storage this means
                                     // that previous values must be zero
diff --git a/crates/database/src/states/bundle_state.rs b/crates/database/src/states/bundle_state.rs
index 6c3e4e8077..6bcbf7f726 100644
--- a/crates/database/src/states/bundle_state.rs
+++ b/crates/database/src/states/bundle_state.rs
@@ -7,7 +7,8 @@ use super::{
 use bytecode::Bytecode;
 use core::{mem, ops::RangeInclusive};
 use primitives::{
-    hash_map::Entry, Address, HashMap, HashSet, StorageKey, StorageValue, B256, KECCAK_EMPTY,
+    hash_map::Entry, Address, AddressMap, AddressSet, B256Map, HashMap, StorageKey, StorageKeyMap,
+    StorageValue, B256, KECCAK_EMPTY,
 };
 use state::AccountInfo;
 use std::{
@@ -18,17 +19,17 @@ use std::{
 /// This builder is used to help to facilitate the initialization of `BundleState` struct
 #[derive(Debug)]
 pub struct BundleBuilder {
-    states: HashSet<Address>,
-    state_original: HashMap<Address, AccountInfo>,
-    state_present: HashMap<Address, AccountInfo>,
-    state_storage: HashMap<Address, HashMap<StorageKey, (StorageValue, StorageValue)>>,
+    states: AddressSet,
+    state_original: AddressMap<AccountInfo>,
+    state_present: AddressMap<AccountInfo>,
+    state_storage: AddressMap<StorageKeyMap<(StorageValue, StorageValue)>>,
 
     reverts: BTreeSet<(u64, Address)>,
     revert_range: RangeInclusive<u64>,
     revert_account: HashMap<(u64, Address), Option<Option<AccountInfo>>>,
     revert_storage: HashMap<(u64, Address), Vec<(StorageKey, StorageValue)>>,
 
-    contracts: HashMap<B256, Bytecode>,
+    contracts: B256Map<Bytecode>,
 }
 
 /// Option for [`BundleState`] when converting it to the plain state.
@@ -56,15 +57,15 @@ impl OriginalValuesKnown {
 impl Default for BundleBuilder {
     fn default() -> Self {
         BundleBuilder {
-            states: HashSet::default(),
-            state_original: HashMap::default(),
-            state_present: HashMap::default(),
-            state_storage: HashMap::default(),
+            states: AddressSet::default(),
+            state_original: AddressMap::default(),
+            state_present: AddressMap::default(),
+            state_storage: AddressMap::default(),
             reverts: BTreeSet::new(),
             revert_range: 0..=0,
             revert_account: HashMap::default(),
             revert_storage: HashMap::default(),
-            contracts: HashMap::default(),
+            contracts: B256Map::default(),
         }
     }
 }
@@ -119,7 +120,7 @@ impl BundleBuilder {
     pub fn state_storage(
         mut self,
         address: Address,
-        storage: HashMap<StorageKey, (StorageValue, StorageValue)>,
+        storage: StorageKeyMap<(StorageValue, StorageValue)>,
     ) -> Self {
         self.set_state_storage(address, storage);
         self
@@ -200,7 +201,7 @@ impl BundleBuilder {
     pub fn set_state_storage(
         &mut self,
         address: Address,
-        storage: HashMap<StorageKey, (StorageValue, StorageValue)>,
+        storage: StorageKeyMap<(StorageValue, StorageValue)>,
     ) -> &mut Self {
         self.states.insert(address);
         self.state_storage.insert(address, storage);
@@ -319,29 +320,29 @@ impl BundleBuilder {
     }
 
     /// Getter for `states` field
-    pub fn get_states(&self) -> &HashSet<Address> {
+    pub fn get_states(&self) -> &AddressSet {
         &self.states
     }
 
     /// Mutable getter for `states` field
-    pub fn get_states_mut(&mut self) -> &mut HashSet<Address> {
+    pub fn get_states_mut(&mut self) -> &mut AddressSet {
         &mut self.states
     }
 
     /// Mutable getter for `state_original` field
-    pub fn get_state_original_mut(&mut self) -> &mut HashMap<Address, AccountInfo> {
+    pub fn get_state_original_mut(&mut self) -> &mut AddressMap<AccountInfo> {
         &mut self.state_original
     }
 
     /// Mutable getter for `state_present` field
-    pub fn get_state_present_mut(&mut self) -> &mut HashMap<Address, AccountInfo> {
+    pub fn get_state_present_mut(&mut self) -> &mut AddressMap<AccountInfo> {
         &mut self.state_present
     }
 
     /// Mutable getter for `state_storage` field
     pub fn get_state_storage_mut(
         &mut self,
-    ) -> &mut HashMap<Address, HashMap<StorageKey, (StorageValue, StorageValue)>> {
+    ) -> &mut AddressMap<StorageKeyMap<(StorageValue, StorageValue)>> {
         &mut self.state_storage
     }
 
@@ -370,7 +371,7 @@ impl BundleBuilder {
     }
 
     /// Mutable getter for `contracts` field
-    pub fn get_contracts_mut(&mut self) -> &mut HashMap<B256, Bytecode> {
+    pub fn get_contracts_mut(&mut self) -> &mut B256Map<Bytecode> {
         &mut self.contracts
     }
 }
@@ -404,9 +405,9 @@ impl BundleRetention {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct BundleState {
     /// Account state
-    pub state: HashMap<Address, BundleAccount>,
+    pub state: AddressMap<BundleAccount>,
     /// All created contracts in this block.
-    pub contracts: HashMap<B256, Bytecode>,
+    pub contracts: B256Map<Bytecode>,
     /// Changes to revert
     ///
     /// **Note**: Inside vector is *not* sorted by address.
@@ -512,7 +513,7 @@ impl BundleState {
     }
 
     /// Returns reference to the state.
-    pub fn state(&self) -> &HashMap<Address, BundleAccount> {
+    pub fn state(&self) -> &AddressMap<BundleAccount> {
         &self.state
     }
 
@@ -689,7 +690,7 @@ impl BundleState {
     /// Extends the bundle with other state.
     ///
     /// Updates the `other` state only if `other` is not flagged as destroyed.
-    pub fn extend_state(&mut self, other_state: HashMap<Address, BundleAccount>) {
+    pub fn extend_state(&mut self, other_state: AddressMap<BundleAccount>) {
         for (address, other_account) in other_state {
             match self.state.entry(address) {
                 Entry::Occupied(mut entry) => {
diff --git a/crates/database/src/states/plain_account.rs b/crates/database/src/states/plain_account.rs
index 1dfa8aa5ba..75bc5b3fb2 100644
--- a/crates/database/src/states/plain_account.rs
+++ b/crates/database/src/states/plain_account.rs
@@ -1,4 +1,4 @@
-use primitives::{HashMap, StorageKey, StorageValue};
+use primitives::{HashMap, StorageKeyMap, StorageValue};
 use state::{AccountInfo, EvmStorageSlot};
 
 /// Plain account of StateDatabase.
@@ -84,11 +84,11 @@ impl StorageSlot {
 /// This storage represent values that are before block changed.
 ///
 /// Note: Storage that we get EVM contains original values before block changed.
-pub type StorageWithOriginalValues = HashMap<StorageKey, StorageSlot>;
+pub type StorageWithOriginalValues = StorageKeyMap<StorageSlot>;
 
 /// Simple plain storage that does not have previous value.
 /// This is used for loading from database, cache and for bundle state.
-pub type PlainStorage = HashMap<StorageKey, StorageValue>;
+pub type PlainStorage = StorageKeyMap<StorageValue>;
 
 impl From<AccountInfo> for PlainAccount {
     fn from(info: AccountInfo) -> Self {
diff --git a/crates/database/src/states/reverts.rs b/crates/database/src/states/reverts.rs
index 4b8d989d3f..7a84035d09 100644
--- a/crates/database/src/states/reverts.rs
+++ b/crates/database/src/states/reverts.rs
@@ -6,7 +6,7 @@ use core::{
     cmp::Ordering,
     ops::{Deref, DerefMut},
 };
-use primitives::{Address, HashMap, StorageKey, StorageValue};
+use primitives::{Address, StorageKeyMap, StorageValue};
 use state::AccountInfo;
 use std::vec::Vec;
 
@@ -145,7 +145,7 @@ pub struct AccountRevert {
     /// Account information revert.
     pub account: AccountInfoRevert,
     /// Storage slots to revert.
-    pub storage: HashMap<StorageKey, RevertToSlot>,
+    pub storage: StorageKeyMap<RevertToSlot>,
     /// Previous account status before the change.
     pub previous_status: AccountStatus,
     /// Whether to wipe the storage.
@@ -170,7 +170,7 @@ impl AccountRevert {
     ) -> Self {
         // Take present storage values as the storages that we are going to revert to.
         // As those values got destroyed.
-        let mut previous_storage: HashMap<StorageKey, RevertToSlot> = previous_storage
+        let mut previous_storage: StorageKeyMap<RevertToSlot> = previous_storage
             .drain()
             .map(|(key, value)| (key, RevertToSlot::Some(value.present_value)))
             .collect();
diff --git a/crates/database/src/states/state.rs b/crates/database/src/states/state.rs
index 64c49fc7a7..d8e7841eec 100644
--- a/crates/database/src/states/state.rs
+++ b/crates/database/src/states/state.rs
@@ -9,7 +9,7 @@ use database_interface::{
     bal::{BalState, EvmDatabaseError},
     Database, DatabaseCommit, DatabaseRef, EmptyDB,
 };
-use primitives::{hash_map, Address, HashMap, StorageKey, StorageValue, B256};
+use primitives::{hash_map, Address, AddressMap, HashMap, StorageKey, StorageValue, B256};
 use state::{
     bal::{alloy::AlloyBal, Bal},
     Account, AccountInfo,
@@ -372,7 +372,7 @@ impl<DB: Database> Database for State<DB> {
 }
 
 impl<DB: Database> DatabaseCommit for State<DB> {
-    fn commit(&mut self, changes: HashMap<Address, Account>) {
+    fn commit(&mut self, changes: AddressMap<Account>) {
         self.bal_state.commit(&changes);
         let transitions = self.cache.apply_evm_state_iter(changes, |_, _| {});
         if let Some(s) = self.transition_state.as_mut() {
diff --git a/crates/database/src/states/transition_state.rs b/crates/database/src/states/transition_state.rs
index 78fdd40e73..06654d00af 100644
--- a/crates/database/src/states/transition_state.rs
+++ b/crates/database/src/states/transition_state.rs
@@ -1,11 +1,11 @@
 use super::TransitionAccount;
-use primitives::{hash_map::Entry, Address, HashMap};
+use primitives::{hash_map::Entry, Address, AddressMap, HashMap};
 
 /// State of accounts in transition between transaction executions.
 #[derive(Clone, Default, Debug, PartialEq, Eq)]
 pub struct TransitionState {
     /// Block state account with account state
-    pub transitions: HashMap<Address, TransitionAccount>,
+    pub transitions: AddressMap<TransitionAccount>,
 }
 
 impl TransitionState {
diff --git a/crates/handler/src/pre_execution.rs b/crates/handler/src/pre_execution.rs
index 88dc789b83..a2eeb2de57 100644
--- a/crates/handler/src/pre_execution.rs
+++ b/crates/handler/src/pre_execution.rs
@@ -11,7 +11,7 @@ use context_interface::{
     Block, Cfg, ContextTr, Database,
 };
 use core::cmp::Ordering;
-use primitives::{eip7702, hardfork::SpecId, Address, HashMap, HashSet, StorageKey, U256};
+use primitives::{eip7702, hardfork::SpecId, AddressMap, HashSet, StorageKey, U256};
 use state::AccountInfo;
 
 /// Loads and warms accounts for execution, including precompiles and access list.
@@ -50,7 +50,7 @@ pub fn load_accounts<
     // legacy is only tx type that does not have access list.
     if tx.tx_type() != TransactionType::Legacy {
         if let Some(access_list) = tx.access_list() {
-            let mut map: HashMap<Address, HashSet<StorageKey>> = HashMap::default();
+            let mut map: AddressMap<HashSet<StorageKey>> = AddressMap::default();
             for item in access_list {
                 map.entry(*item.address())
                     .or_default()
diff --git a/crates/precompile/src/lib.rs b/crates/precompile/src/lib.rs
index d3301403e4..c6db1b763f 100644
--- a/crates/precompile/src/lib.rs
+++ b/crates/precompile/src/lib.rs
@@ -54,7 +54,8 @@ use aurora_engine_modexp as _;
 
 use core::hash::Hash;
 use primitives::{
-    hardfork::SpecId, short_address, Address, HashMap, HashSet, OnceLock, SHORT_ADDRESS_CAP,
+    hardfork::SpecId, short_address, Address, AddressMap, AddressSet, HashMap, OnceLock,
+    SHORT_ADDRESS_CAP,
 };
 use std::vec::Vec;
 
@@ -70,13 +71,13 @@ pub fn calc_linear_cost_u32(len: usize, base: u64, word: u64) -> u64 {
     calc_linear_cost(len, base, word)
 }
 
-/// Precompiles contain map of precompile addresses to functions and HashSet of precompile addresses.
+/// Precompiles contain map of precompile addresses to functions and AddressSet of precompile addresses.
 #[derive(Clone, Debug)]
 pub struct Precompiles {
     /// Precompiles
-    inner: HashMap<Address, Precompile>,
+    inner: AddressMap<Precompile>,
     /// Addresses of precompiles.
-    addresses: HashSet<Address>,
+    addresses: AddressSet,
     /// Optimized addresses filter.
     optimized_access: Vec<Option<Precompile>>,
     /// `true` if all precompiles are short addresses.
@@ -87,7 +88,7 @@ impl Default for Precompiles {
     fn default() -> Self {
         Self {
             inner: HashMap::default(),
-            addresses: HashSet::default(),
+            addresses: AddressSet::default(),
             optimized_access: vec![None; SHORT_ADDRESS_CAP],
             all_short_addresses: true,
         }
@@ -124,7 +125,7 @@ impl Precompiles {
     }
 
     /// Returns inner HashMap of precompiles.
-    pub fn inner(&self) -> &HashMap<Address, Precompile> {
+    pub fn inner(&self) -> &AddressMap<Precompile> {
         &self.inner
     }
 
@@ -261,7 +262,7 @@ impl Precompiles {
     }
 
     /// Returns the precompiles addresses as a set.
-    pub fn addresses_set(&self) -> &HashSet<Address> {
+    pub fn addresses_set(&self) -> &AddressSet {
         &self.addresses
     }
 
@@ -296,7 +297,7 @@ impl Precompiles {
             .iter()
             .filter(|(a, _)| !other.inner.contains_key(*a))
             .map(|(a, p)| (*a, p.clone()))
-            .collect::<HashMap<_, _>>();
+            .collect::<AddressMap<_>>();
 
         let mut precompiles = Self::default();
         precompiles.extend(inner.into_iter().map(|p| p.1));
@@ -313,7 +314,7 @@ impl Precompiles {
             .iter()
             .filter(|(a, _)| other.inner.contains_key(*a))
             .map(|(a, p)| (*a, p.clone()))
-            .collect::<HashMap<_, _>>();
+            .collect::<AddressMap<_>>();
 
         let mut precompiles = Self::default();
         precompiles.extend(inner.into_iter().map(|p| p.1));
diff --git a/crates/primitives/src/lib.rs b/crates/primitives/src/lib.rs
index 373f089647..95609a3cd6 100644
--- a/crates/primitives/src/lib.rs
+++ b/crates/primitives/src/lib.rs
@@ -35,7 +35,10 @@ pub use once_lock::OnceLock;
 
 pub use alloy_primitives::{
     self, address, b256, bytes, fixed_bytes, hex, hex_literal, keccak256,
-    map::{self, hash_map, hash_set, indexmap, AddressMap, B256Map, HashMap, HashSet, IndexMap},
+    map::{
+        self, hash_map, hash_set, indexmap, AddressIndexMap, AddressMap, AddressSet, B256Map,
+        HashMap, HashSet, IndexMap, U256Map,
+    },
     ruint, uint, Address, Bytes, FixedBytes, Log, LogData, TxKind, B256, I128, I256, U128, U256,
 };
 
@@ -47,6 +50,9 @@ pub type StorageKey = U256;
 /// Used to store data values in smart contract storage slots.
 pub type StorageValue = U256;
 
+/// Type alias for a map with storage keys (U256) as keys.
+pub type StorageKeyMap<V> = U256Map<V>;
+
 /// Optimize short address access.
 pub const SHORT_ADDRESS_CAP: usize = 300;
 
diff --git a/crates/state/src/bal.rs b/crates/state/src/bal.rs
index bdaaa6953b..07084bb6ab 100644
--- a/crates/state/src/bal.rs
+++ b/crates/state/src/bal.rs
@@ -21,7 +21,7 @@ pub use writes::BalWrites;
 
 use crate::{Account, AccountInfo};
 use alloy_eip7928::BlockAccessList as AlloyBal;
-use primitives::{Address, IndexMap, StorageKey, StorageValue};
+use primitives::{Address, AddressIndexMap, StorageKey, StorageValue};
 
 /// Block access index (0 for pre-execution, 1..n for transactions, n+1 for post-execution)
 pub type BalIndex = u64;
@@ -31,7 +31,7 @@ pub type BalIndex = u64;
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bal {
     /// Accounts bal.
-    pub accounts: IndexMap<Address, AccountBal>,
+    pub accounts: AddressIndexMap<AccountBal>,
 }
 
 impl FromIterator<(Address, AccountBal)> for Bal {
@@ -46,7 +46,7 @@ impl Bal {
     /// Create a new BAL builder.
     pub fn new() -> Self {
         Self {
-            accounts: IndexMap::default(),
+            accounts: AddressIndexMap::default(),
         }
     }
 
diff --git a/crates/state/src/bal/alloy.rs b/crates/state/src/bal/alloy.rs
index f17288fd66..a33417a2e0 100644
--- a/crates/state/src/bal/alloy.rs
+++ b/crates/state/src/bal/alloy.rs
@@ -9,14 +9,14 @@ pub use alloy_eip7928::{
 
 use crate::bal::{AccountBal, Bal, BalWrites};
 use bytecode::{Bytecode, BytecodeDecodeError};
-use primitives::{IndexMap, B256, U256};
+use primitives::{AddressIndexMap, B256, U256};
 use std::vec::Vec;
 
 impl TryFrom<AlloyBal> for Bal {
     type Error = BytecodeDecodeError;
 
     fn try_from(alloy_bal: AlloyBal) -> Result<Self, Self::Error> {
-        let accounts = IndexMap::from_iter(
+        let accounts = AddressIndexMap::from_iter(
             alloy_bal
                 .into_iter()
                 .map(AccountBal::try_from_alloy)
diff --git a/crates/state/src/lib.rs b/crates/state/src/lib.rs
index 2f30473fb5..f857b36688 100644
--- a/crates/state/src/lib.rs
+++ b/crates/state/src/lib.rs
@@ -328,7 +328,7 @@ mod serde_impl {
     struct AccountSerde {
         info: AccountInfo,
         original_info: Option<AccountInfo>,
-        storage: HashMap<StorageKey, EvmStorageSlot>,
+        storage: EvmStorage,
         transaction_id: usize,
         status: AccountStatus,
     }
diff --git a/crates/state/src/types.rs b/crates/state/src/types.rs
index 7c656428ba..daf6c93940 100644
--- a/crates/state/src/types.rs
+++ b/crates/state/src/types.rs
@@ -1,11 +1,11 @@
 use super::{Account, EvmStorageSlot};
-use primitives::{Address, HashMap, StorageKey, StorageValue};
+use primitives::{Address, AddressMap, HashMap, StorageKey, StorageKeyMap, StorageValue};
 
 /// EVM State is a mapping from addresses to accounts.
-pub type EvmState = HashMap<Address, Account>;
+pub type EvmState = AddressMap<Account>;
 
 /// Structure used for EIP-1153 transient storage
 pub type TransientStorage = HashMap<(Address, StorageKey), StorageValue>;
 
 /// An account's Storage is a mapping from 256-bit integer keys to [EvmStorageSlot]s.
-pub type EvmStorage = HashMap<StorageKey, EvmStorageSlot>;
+pub type EvmStorage = StorageKeyMap<EvmStorageSlot>;
diff --git a/crates/statetest-types/src/account_info.rs b/crates/statetest-types/src/account_info.rs
index 0796800bea..dafde28fa3 100644
--- a/crates/statetest-types/src/account_info.rs
+++ b/crates/statetest-types/src/account_info.rs
@@ -1,4 +1,4 @@
-use primitives::{Bytes, HashMap, StorageKey, StorageValue, U256};
+use primitives::{Bytes, StorageKeyMap, StorageValue, U256};
 use serde::Deserialize;
 
 use crate::deserializer::deserialize_str_as_u64;
@@ -15,5 +15,5 @@ pub struct AccountInfo {
     #[serde(deserialize_with = "deserialize_str_as_u64")]
     pub nonce: u64,
     /// Account storage (key-value pairs)
-    pub storage: HashMap<StorageKey, StorageValue>,
+    pub storage: StorageKeyMap<StorageValue>,
 }
diff --git a/crates/statetest-types/src/test.rs b/crates/statetest-types/src/test.rs
index 72bf953c31..172010026e 100644
--- a/crates/statetest-types/src/test.rs
+++ b/crates/statetest-types/src/test.rs
@@ -1,5 +1,5 @@
 use context::tx::TxEnv;
-use primitives::{Address, Bytes, HashMap, TxKind, B256};
+use primitives::{AddressMap, Bytes, TxKind, B256};
 use serde::Deserialize;
 
 use crate::{
@@ -23,7 +23,7 @@ pub struct Test {
     pub hash: B256,
     /// Post state
     #[serde(default)]
-    pub post_state: HashMap<Address, AccountInfo>,
+    pub post_state: AddressMap<AccountInfo>,
 
     /// Logs root
     pub logs: B256,
@@ -32,7 +32,7 @@ pub struct Test {
     ///
     /// Note: Not used.
     #[serde(default)]
-    state: HashMap<Address, AccountInfo>,
+    state: AddressMap<AccountInfo>,
 
     /// Tx bytes
     pub txbytes: Option<Bytes>,
diff --git a/crates/statetest-types/src/test_unit.rs b/crates/statetest-types/src/test_unit.rs
index ec11eb7acf..282aadec8b 100644
--- a/crates/statetest-types/src/test_unit.rs
+++ b/crates/statetest-types/src/test_unit.rs
@@ -1,7 +1,7 @@
 use crate::{AccountInfo, Env, SpecName, Test, TransactionParts};
 use context::{block::BlockEnv, cfg::CfgEnv};
 use database::CacheState;
-use primitives::{hardfork::SpecId, keccak256, Address, Bytes, HashMap, B256};
+use primitives::{hardfork::SpecId, keccak256, AddressMap, Bytes, B256};
 use serde::Deserialize;
 use state::Bytecode;
 use std::collections::BTreeMap;
@@ -27,7 +27,7 @@ pub struct TestUnit {
     /// A mapping of addresses to their account information before the transaction
     /// is executed. This represents the initial state of all accounts involved
     /// in the test, including their balances, nonces, code, and storage.
-    pub pre: HashMap<Address, AccountInfo>,
+    pub pre: AddressMap<AccountInfo>,
 
     /// Post-execution expectations per specification.
     ///
@@ -134,7 +134,7 @@ mod tests {
     use context_interface::block::calc_blob_gasprice;
     use primitives::{
         eip4844::{BLOB_BASE_FEE_UPDATE_FRACTION_CANCUN, BLOB_BASE_FEE_UPDATE_FRACTION_PRAGUE},
-        U256,
+        Address, U256,
     };
 
     /// Creates a minimal TestUnit with excess blob gas set for testing blob fee calculation
@@ -155,7 +155,7 @@ mod tests {
                 current_withdrawals_root: None,
                 current_excess_blob_gas: Some(U256::from(excess_blob_gas)),
             },
-            pre: HashMap::default(),
+            pre: AddressMap::default(),
             post: BTreeMap::default(),
             transaction: TransactionParts {
                 tx_type: None,
diff --git a/examples/cheatcode_inspector/src/main.rs b/examples/cheatcode_inspector/src/main.rs
index 71d5b67690..485cb0c5fc 100644
--- a/examples/cheatcode_inspector/src/main.rs
+++ b/examples/cheatcode_inspector/src/main.rs
@@ -27,7 +27,10 @@ use revm::{
         interpreter::EthInterpreter, CallInputs, CallOutcome, InterpreterResult, SStoreResult,
         SelfDestructResult, StateLoad,
     },
-    primitives::{hardfork::SpecId, Address, HashSet, Log, StorageKey, StorageValue, B256, U256},
+    primitives::{
+        hardfork::SpecId, Address, AddressMap, AddressSet, HashSet, Log, StorageKey, StorageValue,
+        B256, U256,
+    },
     state::{Account, Bytecode, EvmState},
     Context, Database, DatabaseCommit, InspectEvm, Inspector, Journal, JournalEntry,
 };
@@ -117,10 +120,7 @@ impl JournalTr for Backend {
             .selfdestruct(address, target, skip_cold_load)
     }
 
-    fn warm_access_list(
-        &mut self,
-        access_list: revm::primitives::HashMap<Address, HashSet<StorageKey>>,
-    ) {
+    fn warm_access_list(&mut self, access_list: AddressMap<HashSet<StorageKey>>) {
         self.journaled_state.warm_access_list(access_list);
     }
 
@@ -128,11 +128,11 @@ impl JournalTr for Backend {
         self.journaled_state.warm_coinbase_account(address)
     }
 
-    fn warm_precompiles(&mut self, addresses: HashSet<Address>) {
+    fn warm_precompiles(&mut self, addresses: AddressSet) {
         self.journaled_state.warm_precompiles(addresses)
     }
 
-    fn precompile_addresses(&self) -> &HashSet<Address> {
+    fn precompile_addresses(&self) -> &AddressSet {
         self.journaled_state.precompile_addresses()
     }
 
diff --git a/examples/database_components/src/lib.rs b/examples/database_components/src/lib.rs
index 276bc32587..804351935d 100644
--- a/examples/database_components/src/lib.rs
+++ b/examples/database_components/src/lib.rs
@@ -10,7 +10,7 @@ pub use state::{State, StateRef};
 
 use revm::{
     database_interface::{DBErrorMarker, Database, DatabaseCommit, DatabaseRef},
-    primitives::{Address, HashMap, StorageKey, StorageValue, B256},
+    primitives::{Address, AddressMap, StorageKey, StorageValue, B256},
     state::{Account, AccountInfo, Bytecode},
 };
 
@@ -115,7 +115,7 @@ impl<S: StateRef, BH: BlockHashRef> DatabaseRef for DatabaseComponents<S, BH> {
 }
 
 impl<S: DatabaseCommit, BH: BlockHashRef> DatabaseCommit for DatabaseComponents<S, BH> {
-    fn commit(&mut self, changes: HashMap<Address, Account>) {
+    fn commit(&mut self, changes: AddressMap<Account>) {
         self.state.commit(changes);
     }
 }