diff --git a/contracts/axelar-gas-service/src/lib.rs b/contracts/axelar-gas-service/src/lib.rs
index 1ab12574..25c6a3fd 100644
--- a/contracts/axelar-gas-service/src/lib.rs
+++ b/contracts/axelar-gas-service/src/lib.rs
@@ -13,8 +13,8 @@ cfg_if::cfg_if! {
     } else {
         mod event;
         mod storage_types;
+        mod contract;
 
-        pub mod contract;
         pub use contract::{AxelarGasService, AxelarGasServiceClient};
     }
 }
diff --git a/contracts/axelar-gas-service/tests/test.rs b/contracts/axelar-gas-service/tests/test.rs
index 8f748f0b..4f323787 100644
--- a/contracts/axelar-gas-service/tests/test.rs
+++ b/contracts/axelar-gas-service/tests/test.rs
@@ -3,8 +3,8 @@ extern crate std;
 
 use std::format;
 
-use axelar_gas_service::contract::{AxelarGasService, AxelarGasServiceClient};
 use axelar_gas_service::error::ContractError;
+use axelar_gas_service::{AxelarGasService, AxelarGasServiceClient};
 use axelar_soroban_std::{
     assert_contract_err, assert_invoke_auth_err, assert_last_emitted_event, types::Token,
 };
diff --git a/contracts/axelar-gateway/src/lib.rs b/contracts/axelar-gateway/src/lib.rs
index 0af6885d..4234ac48 100644
--- a/contracts/axelar-gateway/src/lib.rs
+++ b/contracts/axelar-gateway/src/lib.rs
@@ -26,8 +26,8 @@ cfg_if::cfg_if! {
         mod auth;
         mod event;
         mod storage_types;
+        mod contract;
 
-        pub mod contract;
         pub use contract::{AxelarGateway, AxelarGatewayClient};
     }
 }
diff --git a/contracts/axelar-operators/src/lib.rs b/contracts/axelar-operators/src/lib.rs
index 97d2da16..49a883c6 100644
--- a/contracts/axelar-operators/src/lib.rs
+++ b/contracts/axelar-operators/src/lib.rs
@@ -3,7 +3,7 @@
 mod event;
 mod storage_types;
 
-pub mod contract;
+mod contract;
 pub mod error;
 
-pub use contract::AxelarOperatorsClient;
+pub use contract::{AxelarOperators, AxelarOperatorsClient};
diff --git a/contracts/axelar-operators/tests/test.rs b/contracts/axelar-operators/tests/test.rs
index c661a98b..5636fd7c 100644
--- a/contracts/axelar-operators/tests/test.rs
+++ b/contracts/axelar-operators/tests/test.rs
@@ -7,7 +7,7 @@ use axelar_soroban_std::{
     testutils::assert_invocation,
 };
 
-use axelar_operators::contract::{AxelarOperators, AxelarOperatorsClient};
+use axelar_operators::{AxelarOperators, AxelarOperatorsClient};
 use soroban_sdk::{
     contract, contractimpl, symbol_short, testutils::Address as _, Address, Env, Symbol, Val, Vec,
 };
diff --git a/contracts/example/src/lib.rs b/contracts/example/src/lib.rs
index 4a93b400..1f9a6d2d 100644
--- a/contracts/example/src/lib.rs
+++ b/contracts/example/src/lib.rs
@@ -1,8 +1,7 @@
 #![no_std]
 
+mod contract;
 mod event;
 mod storage_types;
 
-pub mod contract;
-
-pub use contract::ExampleClient;
+pub use contract::{Example, ExampleClient};
diff --git a/contracts/example/tests/test.rs b/contracts/example/tests/test.rs
index f71b2714..31a3cfab 100644
--- a/contracts/example/tests/test.rs
+++ b/contracts/example/tests/test.rs
@@ -1,14 +1,14 @@
 #![cfg(test)]
 extern crate std;
 
-use axelar_gas_service::contract::AxelarGasService;
+use axelar_gas_service::AxelarGasService;
 use axelar_gas_service::AxelarGasServiceClient;
 use axelar_gateway::testutils::{self, generate_proof, get_approve_hash, TestSignerSet};
 use axelar_gateway::types::Message;
 use axelar_gateway::AxelarGatewayClient;
 use axelar_soroban_std::types::Token;
 use axelar_soroban_std::{assert_last_emitted_event, auth_invocation};
-use example::contract::Example;
+use example::Example;
 use example::ExampleClient;
 use soroban_sdk::testutils::{AuthorizedFunction, AuthorizedInvocation};
 use soroban_sdk::token::StellarAssetClient;
diff --git a/contracts/interchain-token-service/src/abi.rs b/contracts/interchain-token-service/src/abi.rs
index d69bb3c1..6a3741e6 100644
--- a/contracts/interchain-token-service/src/abi.rs
+++ b/contracts/interchain-token-service/src/abi.rs
@@ -250,7 +250,6 @@ mod tests {
     use super::*;
     use alloc::vec;
     use axelar_soroban_std::assert_ok;
-    use core::u128;
     use soroban_sdk::{Bytes, BytesN, Env, String};
     use std::vec::Vec;
 
@@ -264,28 +263,28 @@ mod tests {
         let env = Env::default();
 
         let plain_string = "hello world";
-        let plain_string_soroban = String::from_str(&env, &plain_string);
+        let plain_string_soroban = String::from_str(&env, plain_string);
         assert_eq!(
             to_std_string(plain_string_soroban).unwrap(),
             StdString::from(plain_string)
         );
 
         let var_length_chars = "🎉中🚀π🌈€";
-        let var_length_chars_soroban = String::from_str(&env, &var_length_chars);
+        let var_length_chars_soroban = String::from_str(&env, var_length_chars);
         assert_eq!(
             to_std_string(var_length_chars_soroban).unwrap(),
             StdString::from(var_length_chars)
         );
 
         let null_bytes = "Hello\x00World";
-        let null_bytes_soroban = String::from_str(&env, &null_bytes);
+        let null_bytes_soroban = String::from_str(&env, null_bytes);
         assert_eq!(
             to_std_string(null_bytes_soroban).unwrap(),
             StdString::from(null_bytes)
         );
 
         let escape_char = "Hello\tWorld";
-        let escape_char_soroban = String::from_str(&env, &escape_char);
+        let escape_char_soroban = String::from_str(&env, escape_char);
         assert_eq!(
             to_std_string(escape_char_soroban).unwrap(),
             StdString::from(escape_char)
@@ -297,11 +296,11 @@ mod tests {
         let env = Env::default();
 
         let invalid_sequences = vec![
-            String::from_bytes(&env, &vec![0xF5, 0x90, 0x80]), // not valid utf-8
-            String::from_bytes(&env, &vec![0x00, 0x01, 0x02, 0xC0]), // valid ASCII characters followed by an invalid UTF-8 starting byte
-            String::from_bytes(&env, &vec![0xC0, 0x80, 0xF5, 0x90]), // invalid UTF-8 starting byte followed by valid UTF-8 sequences
-            String::from_bytes(&env, &vec![0xF0, 0x90, 0x80, 0xDF, 0xFB, 0xBF]), // surrogate pairs with invalid charaters "\uD800\uDDFF"
-            String::from_bytes(&env, &vec![0xF4, 0x90, 0x80, 0x80]), // outside the Basic Multilingual Plane
+            String::from_bytes(&env, &[0xF5, 0x90, 0x80]), // not valid utf-8
+            String::from_bytes(&env, &[0x00, 0x01, 0x02, 0xC0]), // valid ASCII characters followed by an invalid UTF-8 starting byte
+            String::from_bytes(&env, &[0xC0, 0x80, 0xF5, 0x90]), // invalid UTF-8 starting byte followed by valid UTF-8 sequences
+            String::from_bytes(&env, &[0xF0, 0x90, 0x80, 0xDF, 0xFB, 0xBF]), // surrogate pairs with invalid charaters "\uD800\uDDFF"
+            String::from_bytes(&env, &[0xF4, 0x90, 0x80, 0x80]), // outside the Basic Multilingual Plane
         ];
 
         for sequence in invalid_sequences {
@@ -358,7 +357,7 @@ mod tests {
     #[test]
     fn interchain_transfer_encode_decode() {
         let env = Env::default();
-        let remote_chain = String::from_str(&env, &"chain");
+        let remote_chain = String::from_str(&env, "chain");
 
         let cases = vec![
             types::HubMessage::SendToHub {
@@ -367,10 +366,9 @@ mod tests {
                     token_id: BytesN::from_array(&env, &[0u8; 32]),
                     source_address: bytes_from_hex(&env, "00"),
                     destination_address: bytes_from_hex(&env, "00"),
-                    amount: 1u64.try_into().unwrap(),
+                    amount: 1u64.into(),
                     data: None,
-                })
-                .into(),
+                }),
             },
             types::HubMessage::SendToHub {
                 destination_chain: remote_chain.clone(),
@@ -386,8 +384,7 @@ mod tests {
                     ),
                     amount: i128::MAX,
                     data: Some(bytes_from_hex(&env, "abcd")),
-                })
-                .into(),
+                }),
             },
             types::HubMessage::ReceiveFromHub {
                 source_chain: remote_chain.clone(),
@@ -395,13 +392,12 @@ mod tests {
                     token_id: BytesN::from_array(&env, &[0u8; 32]),
                     source_address: bytes_from_hex(&env, "00"),
                     destination_address: bytes_from_hex(&env, "00"),
-                    amount: 1u64.try_into().unwrap(),
+                    amount: 1u64.into(),
                     data: None,
-                })
-                .into(),
+                }),
             },
             types::HubMessage::ReceiveFromHub {
-                source_chain: remote_chain.clone(),
+                source_chain: remote_chain,
                 message: types::Message::InterchainTransfer(types::InterchainTransfer {
                     token_id: BytesN::from_array(&env, &[255u8; 32]),
                     source_address: bytes_from_hex(
@@ -414,8 +410,7 @@ mod tests {
                     ),
                     amount: i128::MAX,
                     data: Some(bytes_from_hex(&env, "abcd")),
-                })
-                .into(),
+                }),
             },
         ];
 
@@ -442,74 +437,68 @@ mod tests {
     #[test]
     fn deploy_interchain_token_encode_decode() {
         let env = Env::default();
-        let remote_chain = String::from_str(&env, &"chain");
+        let remote_chain = String::from_str(&env, "chain");
 
         let cases = vec![
             types::HubMessage::SendToHub {
                 destination_chain: remote_chain.clone(),
                 message: types::Message::DeployInterchainToken(types::DeployInterchainToken {
                     token_id: BytesN::from_array(&env, &[0u8; 32]),
-                    name: String::from_str(&env, &"t"),
-                    symbol: String::from_str(&env, &"T"),
+                    name: String::from_str(&env, "t"),
+                    symbol: String::from_str(&env, "T"),
                     decimals: 0,
                     minter: None,
-                })
-                .into(),
+                }),
             },
             types::HubMessage::SendToHub {
                 destination_chain: remote_chain.clone(),
                 message: types::Message::DeployInterchainToken(types::DeployInterchainToken {
                     token_id: BytesN::from_array(&env, &[1u8; 32]),
-                    name: String::from_str(&env, &"Test Token"),
-                    symbol: String::from_str(&env, &"TST"),
+                    name: String::from_str(&env, "Test Token"),
+                    symbol: String::from_str(&env, "TST"),
                     decimals: 18,
                     minter: Some(bytes_from_hex(&env, "1234")),
-                })
-                .into(),
+                }),
             },
             types::HubMessage::SendToHub {
                 destination_chain: remote_chain.clone(),
                 message: types::Message::DeployInterchainToken(types::DeployInterchainToken {
                     token_id: BytesN::from_array(&env, &[0u8; 32]),
-                    name: String::from_str(&env, &"Unicode Token 🪙"),
-                    symbol: String::from_str(&env, &"UNI🔣"),
+                    name: String::from_str(&env, "Unicode Token 🪙"),
+                    symbol: String::from_str(&env, "UNI🔣"),
                     decimals: 255,
                     minter: Some(bytes_from_hex(&env, "abcd")),
-                })
-                .into(),
+                }),
             },
             types::HubMessage::ReceiveFromHub {
                 source_chain: remote_chain.clone(),
                 message: types::Message::DeployInterchainToken(types::DeployInterchainToken {
                     token_id: BytesN::from_array(&env, &[0u8; 32]),
-                    name: String::from_str(&env, &"t"),
-                    symbol: String::from_str(&env, &"T"),
+                    name: String::from_str(&env, "t"),
+                    symbol: String::from_str(&env, "T"),
                     decimals: 0,
                     minter: None,
-                })
-                .into(),
+                }),
             },
             types::HubMessage::ReceiveFromHub {
                 source_chain: remote_chain.clone(),
                 message: types::Message::DeployInterchainToken(types::DeployInterchainToken {
                     token_id: BytesN::from_array(&env, &[1u8; 32]),
-                    name: String::from_str(&env, &"Test Token"),
-                    symbol: String::from_str(&env, &"TST"),
+                    name: String::from_str(&env, "Test Token"),
+                    symbol: String::from_str(&env, "TST"),
                     decimals: 18,
                     minter: Some(bytes_from_hex(&env, "1234")),
-                })
-                .into(),
+                }),
             },
             types::HubMessage::ReceiveFromHub {
-                source_chain: remote_chain.clone(),
+                source_chain: remote_chain,
                 message: types::Message::DeployInterchainToken(types::DeployInterchainToken {
                     token_id: BytesN::from_array(&env, &[0u8; 32]),
-                    name: String::from_str(&env, &"Unicode Token 🪙"),
-                    symbol: String::from_str(&env, &"UNI🔣"),
+                    name: String::from_str(&env, "Unicode Token 🪙"),
+                    symbol: String::from_str(&env, "UNI🔣"),
                     decimals: 255,
                     minter: Some(bytes_from_hex(&env, "abcd")),
-                })
-                .into(),
+                }),
             },
         ];
 
@@ -547,7 +536,7 @@ mod tests {
                 token_id: BytesN::from_array(&env, &[0u8; 32]),
                 source_address: bytes_from_hex(&env, "00"),
                 destination_address: bytes_from_hex(&env, "00"),
-                amount: 1u64.try_into().unwrap(),
+                amount: 1u64.into(),
                 data: None,
             }
         )
diff --git a/contracts/interchain-token-service/src/interface.rs b/contracts/interchain-token-service/src/interface.rs
index be6930c1..e93d06a7 100644
--- a/contracts/interchain-token-service/src/interface.rs
+++ b/contracts/interchain-token-service/src/interface.rs
@@ -4,6 +4,7 @@ use soroban_sdk::{contractclient, Address, Bytes, BytesN, Env, String};
 
 use crate::error::ContractError;
 
+#[allow(dead_code)]
 #[contractclient(name = "InterchainTokenServiceClient")]
 pub trait InterchainTokenServiceInterface: AxelarExecutableInterface {
     fn trusted_address(env: &Env, chain: String) -> Option<String>;
diff --git a/contracts/interchain-token-service/src/lib.rs b/contracts/interchain-token-service/src/lib.rs
index 178f4c0e..560eb724 100644
--- a/contracts/interchain-token-service/src/lib.rs
+++ b/contracts/interchain-token-service/src/lib.rs
@@ -1,15 +1,14 @@
 #![no_std]
 
 mod abi;
+mod contract;
 pub mod error;
 mod event;
 mod interface;
 mod storage_types;
 mod types;
 
-pub mod contract;
-
 #[cfg(test)]
 extern crate std;
 
-pub use contract::InterchainTokenServiceClient;
+pub use contract::{InterchainTokenService, InterchainTokenServiceClient};
diff --git a/contracts/interchain-token-service/tests/test.rs b/contracts/interchain-token-service/tests/test.rs
index 53945085..df7761a0 100644
--- a/contracts/interchain-token-service/tests/test.rs
+++ b/contracts/interchain-token-service/tests/test.rs
@@ -1,8 +1,8 @@
 use axelar_gas_service::{AxelarGasService, AxelarGasServiceClient};
 use axelar_gateway::testutils;
 use axelar_gateway::AxelarGatewayClient;
-use interchain_token_service::contract::{InterchainTokenService, InterchainTokenServiceClient};
 use interchain_token_service::error::ContractError;
+use interchain_token_service::{InterchainTokenService, InterchainTokenServiceClient};
 
 use axelar_soroban_std::{assert_contract_err, assert_invoke_auth_err, assert_last_emitted_event};
 
@@ -16,7 +16,7 @@ fn setup_gateway<'a>(env: &Env) -> AxelarGatewayClient<'a> {
 
 fn setup_gas_service<'a>(env: &Env) -> AxelarGasServiceClient<'a> {
     let owner: Address = Address::generate(env);
-    let gas_collector: Address = Address::generate(&env);
+    let gas_collector: Address = Address::generate(env);
     let gas_service_id = env.register(AxelarGasService, (&owner, &gas_collector));
     let gas_service_client = AxelarGasServiceClient::new(env, &gas_service_id);
 
diff --git a/contracts/interchain-token/src/interface.rs b/contracts/interchain-token/src/interface.rs
index 103fee2a..453e798d 100644
--- a/contracts/interchain-token/src/interface.rs
+++ b/contracts/interchain-token/src/interface.rs
@@ -2,6 +2,7 @@ use soroban_sdk::{contractclient, token, Address, BytesN, Env};
 
 use crate::error::ContractError;
 
+#[allow(dead_code)]
 #[contractclient(name = "InterchainTokenClient")]
 pub trait InterchainTokenInterface: token::Interface {
     fn token_id(env: &Env) -> BytesN<32>;
diff --git a/contracts/interchain-token/src/lib.rs b/contracts/interchain-token/src/lib.rs
index 68585d26..fbe55b54 100644
--- a/contracts/interchain-token/src/lib.rs
+++ b/contracts/interchain-token/src/lib.rs
@@ -10,8 +10,8 @@ cfg_if::cfg_if! {
     } else {
         mod event;
         mod storage_types;
+        mod contract;
 
-        pub mod contract;
         pub use contract::{InterchainToken, InterchainTokenClient};
     }
 }
diff --git a/contracts/interchain-token/tests/test.rs b/contracts/interchain-token/tests/test.rs
index 096d930e..7b27f58e 100644
--- a/contracts/interchain-token/tests/test.rs
+++ b/contracts/interchain-token/tests/test.rs
@@ -5,7 +5,7 @@ use axelar_soroban_std::{
     assert_invoke_auth_err, assert_invoke_auth_ok, assert_last_emitted_event,
 };
 
-use interchain_token::contract::{InterchainToken, InterchainTokenClient};
+use interchain_token::{InterchainToken, InterchainTokenClient};
 use soroban_sdk::{
     testutils::{Address as _, BytesN as _},
     Address, BytesN, Env, IntoVal as _, Symbol,
@@ -13,10 +13,10 @@ use soroban_sdk::{
 use soroban_token_sdk::metadata::TokenMetadata;
 
 fn setup_token<'a>(env: &Env) -> (InterchainTokenClient<'a>, Address, Address) {
-    let owner = Address::generate(&env);
-    let minter = Address::generate(&env);
-    let interchain_token_service = Address::generate(&env);
-    let token_id: BytesN<32> = BytesN::<32>::random(&env);
+    let owner = Address::generate(env);
+    let minter = Address::generate(env);
+    let interchain_token_service = Address::generate(env);
+    let token_id: BytesN<32> = BytesN::<32>::random(env);
     let token_meta_data = TokenMetadata {
         decimal: 6,
         name: "name".into_val(env),
@@ -123,8 +123,8 @@ fn register_interchain_token() {
     let (token, owner, minter) = setup_token(&env);
 
     assert_eq!(token.owner(), owner);
-    assert_eq!(token.is_minter(&owner), false);
-    assert_eq!(token.is_minter(&minter), true);
+    assert!(!token.is_minter(&owner));
+    assert!(token.is_minter(&minter));
 }
 
 #[test]
diff --git a/contracts/upgrader/src/lib.rs b/contracts/upgrader/src/lib.rs
index c5aa892e..385e10f9 100644
--- a/contracts/upgrader/src/lib.rs
+++ b/contracts/upgrader/src/lib.rs
@@ -2,5 +2,7 @@
 #[cfg(test)]
 extern crate alloc;
 
-pub mod contract;
+mod contract;
 pub mod error;
+
+pub use contract::{Upgrader, UpgraderClient};
diff --git a/contracts/upgrader/tests/atomic_upgrades.rs b/contracts/upgrader/tests/atomic_upgrades.rs
index accd867f..162e6042 100644
--- a/contracts/upgrader/tests/atomic_upgrades.rs
+++ b/contracts/upgrader/tests/atomic_upgrades.rs
@@ -3,7 +3,7 @@ mod utils;
 use soroban_sdk::testutils::{Address as _, MockAuth, MockAuthInvoke};
 use soroban_sdk::Address;
 use soroban_sdk::{BytesN, Env, String};
-use upgrader::contract::{Upgrader, UpgraderClient};
+use upgrader::{Upgrader, UpgraderClient};
 use utils::{DataKey, DummyContract, DummyContractClient};
 
 const WASM_AFTER_UPGRADE: &[u8] = include_bytes!("testdata/dummy.wasm");
diff --git a/packages/axelar-soroban-std/src/interfaces/operatable.rs b/packages/axelar-soroban-std/src/interfaces/operatable.rs
index 10305b5a..c64f6c5a 100644
--- a/packages/axelar-soroban-std/src/interfaces/operatable.rs
+++ b/packages/axelar-soroban-std/src/interfaces/operatable.rs
@@ -85,7 +85,7 @@ mod storage {
 
 #[cfg(test)]
 mod test {
-    use crate::interfaces::testdata::contract::Contract;
+    use crate::interfaces::testdata::Contract;
     use crate::interfaces::{OperatableClient, OperatorshipTransferredEvent};
     use crate::{assert_invoke_auth_err, assert_invoke_auth_ok, events};
     use soroban_sdk::testutils::Address as _;
diff --git a/packages/axelar-soroban-std/src/interfaces/ownable.rs b/packages/axelar-soroban-std/src/interfaces/ownable.rs
index 8b8b92e3..cc6478f0 100644
--- a/packages/axelar-soroban-std/src/interfaces/ownable.rs
+++ b/packages/axelar-soroban-std/src/interfaces/ownable.rs
@@ -85,7 +85,7 @@ mod storage {
 
 #[cfg(test)]
 mod test {
-    use crate::interfaces::testdata::contract::Contract;
+    use crate::interfaces::testdata::Contract;
     use crate::interfaces::{OwnableClient, OwnershipTransferredEvent};
     use crate::{assert_invoke_auth_err, assert_invoke_auth_ok, events};
     use soroban_sdk::testutils::Address as _;
diff --git a/packages/axelar-soroban-std/src/interfaces/testdata/contract.rs b/packages/axelar-soroban-std/src/interfaces/testdata/contract.rs
index aa296ce1..04211040 100644
--- a/packages/axelar-soroban-std/src/interfaces/testdata/contract.rs
+++ b/packages/axelar-soroban-std/src/interfaces/testdata/contract.rs
@@ -87,3 +87,30 @@ pub enum DataKey {
 pub enum ContractError {
     SomeFailure = 1,
 }
+
+mod test {
+    use soroban_sdk::{contracttype, Address, Env};
+
+    use super::{Contract, DataKey};
+
+    #[test]
+    fn contracttype_enum_name_is_irrelevant_for_key_collision() {
+        let env = Env::default();
+        let contract_id = env.register(Contract, (None::<Address>, None::<Address>));
+
+        env.as_contract(&contract_id, || {
+            assert!(!env.storage().instance().has(&DataKey::Migrating));
+            assert!(!env.storage().instance().has(&DataKey2::Migrating));
+
+            env.storage().instance().set(&DataKey::Migrating, &());
+
+            assert!(env.storage().instance().has(&DataKey::Migrating));
+            assert!(env.storage().instance().has(&DataKey2::Migrating));
+        });
+    }
+
+    #[contracttype]
+    enum DataKey2 {
+        Migrating,
+    }
+}
diff --git a/packages/axelar-soroban-std/src/interfaces/testdata/mod.rs b/packages/axelar-soroban-std/src/interfaces/testdata/mod.rs
index 2943dbb5..b961ef15 100644
--- a/packages/axelar-soroban-std/src/interfaces/testdata/mod.rs
+++ b/packages/axelar-soroban-std/src/interfaces/testdata/mod.rs
@@ -1 +1,3 @@
-pub mod contract;
+mod contract;
+
+pub use contract::{Contract, ContractClient};
diff --git a/packages/axelar-soroban-std/src/interfaces/upgradable.rs b/packages/axelar-soroban-std/src/interfaces/upgradable.rs
index 8bfd44e4..7d2dd350 100644
--- a/packages/axelar-soroban-std/src/interfaces/upgradable.rs
+++ b/packages/axelar-soroban-std/src/interfaces/upgradable.rs
@@ -126,10 +126,10 @@ mod test {
     use crate::interfaces::upgradable::UpgradedEvent;
     use crate::{assert_invoke_auth_err, assert_invoke_auth_ok, events};
 
-    use crate::interfaces::testdata::contract::ContractClient;
+    use crate::interfaces::testdata::ContractClient;
     use crate::interfaces::{testdata, upgradable};
     use soroban_sdk::testutils::Address as _;
-    use soroban_sdk::{contracttype, Address, BytesN, Env, String};
+    use soroban_sdk::{Address, BytesN, Env, String};
 
     const WASM: &[u8] = include_bytes!("testdata/contract.wasm");
 
@@ -138,38 +138,12 @@ mod test {
         owner: Option<Address>,
     ) -> (ContractClient, BytesN<32>) {
         let operator = Address::generate(env);
-        let contract_id = env.register(testdata::contract::Contract, (owner, operator));
+        let contract_id = env.register(testdata::Contract, (owner, operator));
         let hash = env.deployer().upload_contract_wasm(WASM);
         let client = ContractClient::new(env, &contract_id);
         (client, hash)
     }
 
-    #[test]
-    fn contracttype_enum_name_is_irrelevant_for_key_collision() {
-        let env = Env::default();
-        let contract_id = env.register(
-            testdata::contract::Contract,
-            (None::<Address>, None::<Address>),
-        );
-
-        env.as_contract(&contract_id, || {
-            assert!(!env
-                .storage()
-                .instance()
-                .has(&testdata::contract::DataKey::Migrating));
-            assert!(!env.storage().instance().has(&DataKey2::Migrating));
-
-            env.storage()
-                .instance()
-                .set(&testdata::contract::DataKey::Migrating, &());
-
-            assert!(env
-                .storage()
-                .instance()
-                .has(&testdata::contract::DataKey::Migrating));
-            assert!(env.storage().instance().has(&DataKey2::Migrating));
-        });
-    }
     #[test]
     fn upgrade_fails_if_owner_not_set() {
         let env = Env::default();
@@ -260,10 +234,7 @@ mod test {
     fn simulate_migration_for_code_coverage() {
         let env = Env::default();
         let owner = Address::generate(&env);
-        let contract_id = env.register(
-            testdata::contract::Contract,
-            (Some(owner.clone()), None::<Address>),
-        );
+        let contract_id = env.register(testdata::Contract, (Some(owner.clone()), None::<Address>));
 
         env.as_contract(&contract_id, || {
             upgradable::start_migration(&env);
@@ -283,9 +254,4 @@ mod test {
         assert_invoke_auth_ok!(owner, client.try_migrate(&()));
         assert_invoke_auth_err!(owner, client.try_migrate(&()));
     }
-
-    #[contracttype]
-    enum DataKey2 {
-        Migrating,
-    }
 }