diff --git a/justfile b/justfile
index 0a02ee7d3..a75b0052b 100644
--- a/justfile
+++ b/justfile
@@ -35,6 +35,11 @@ clippy-fix:
         -A clippy::todo \
         -A clippy::unimplemented \
         -A clippy::indexing_slicing
+    @echo "Running cargo clippy with automatic fixes on potentially dirty code..."
+    cargo +{{RUSTV}} clippy --fix --allow-dirty --workspace --all-targets -- \
+        -A clippy::todo \
+        -A clippy::unimplemented \
+        -A clippy::indexing_slicing
 fix:
   @echo "Running cargo fix..."
   cargo +{{RUSTV}} fix --workspace
@@ -46,5 +51,4 @@ lint:
   @echo "Running cargo clippy with automatic fixes on potentially dirty code..."
   just clippy-fix
   @echo "Running cargo clippy..."
-  just clippy
-
+  just clippy
\ No newline at end of file
diff --git a/pallets/admin-utils/tests/mock.rs b/pallets/admin-utils/tests/mock.rs
index 16a1f79f4..a78eb6d3d 100644
--- a/pallets/admin-utils/tests/mock.rs
+++ b/pallets/admin-utils/tests/mock.rs
@@ -110,6 +110,7 @@ parameter_types! {
     pub const InitialSubnetLimit: u16 = 10; // Max 10 subnets.
     pub const InitialNetworkRateLimit: u64 = 0;
     pub const InitialTargetStakesPerInterval: u16 = 1;
+    pub const InitialHotkeySwapCost: u64 = 1_000_000_000;
     pub const InitialAlphaHigh: u16 = 58982; // Represents 0.9 as per the production default
     pub const InitialAlphaLow: u16 = 45875; // Represents 0.7 as per the production default
     pub const InitialLiquidAlphaOn: bool = false; // Default value for LiquidAlphaOn
@@ -164,6 +165,7 @@ impl pallet_subtensor::Config for Test {
     type InitialSubnetLimit = InitialSubnetLimit;
     type InitialNetworkRateLimit = InitialNetworkRateLimit;
     type InitialTargetStakesPerInterval = InitialTargetStakesPerInterval;
+    type HotkeySwapCost = InitialHotkeySwapCost;
     type AlphaHigh = InitialAlphaHigh;
     type AlphaLow = InitialAlphaLow;
     type LiquidAlphaOn = InitialLiquidAlphaOn;
diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index f50d0c722..64aefcfee 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -43,6 +43,7 @@ mod registration;
 mod root;
 mod serving;
 mod staking;
+mod swap;
 mod uids;
 mod utils;
 mod weights;
@@ -238,6 +239,9 @@ pub mod pallet {
         /// Initial target stakes per interval issuance.
         #[pallet::constant]
         type InitialTargetStakesPerInterval: Get<u64>;
+        /// Cost of swapping a hotkey.
+        #[pallet::constant]
+        type HotkeySwapCost: Get<u64>;
         /// The upper bound for the alpha parameter. Used for Liquid Alpha.
         #[pallet::constant]
         type AlphaHigh: Get<u16>;
@@ -740,7 +744,7 @@ pub mod pallet {
     pub(super) type TxDelegateTakeRateLimit<T> =
         StorageValue<_, u64, ValueQuery, DefaultTxDelegateTakeRateLimit<T>>;
     #[pallet::storage] // --- MAP ( key ) --> last_block
-    pub(super) type LastTxBlock<T: Config> =
+    pub type LastTxBlock<T: Config> =
         StorageMap<_, Identity, T::AccountId, u64, ValueQuery, DefaultLastTxBlock<T>>;
     #[pallet::storage] // --- MAP ( key ) --> last_block
     pub(super) type LastTxBlockDelegateTake<T: Config> =
@@ -756,10 +760,10 @@ pub mod pallet {
     pub type ServingRateLimit<T> =
         StorageMap<_, Identity, u16, u64, ValueQuery, DefaultServingRateLimit<T>>;
     #[pallet::storage] // --- MAP ( netuid, hotkey ) --> axon_info
-    pub(super) type Axons<T: Config> =
+    pub type Axons<T: Config> =
         StorageDoubleMap<_, Identity, u16, Blake2_128Concat, T::AccountId, AxonInfoOf, OptionQuery>;
     #[pallet::storage] // --- MAP ( netuid, hotkey ) --> prometheus_info
-    pub(super) type Prometheus<T: Config> = StorageDoubleMap<
+    pub type Prometheus<T: Config> = StorageDoubleMap<
         _,
         Identity,
         u16,
@@ -1013,13 +1017,13 @@ pub mod pallet {
     }
 
     #[pallet::storage] // --- DMAP ( netuid, hotkey ) --> uid
-    pub(super) type Uids<T: Config> =
+    pub type Uids<T: Config> =
         StorageDoubleMap<_, Identity, u16, Blake2_128Concat, T::AccountId, u16, OptionQuery>;
     #[pallet::storage] // --- DMAP ( netuid, uid ) --> hotkey
-    pub(super) type Keys<T: Config> =
+    pub type Keys<T: Config> =
         StorageDoubleMap<_, Identity, u16, Identity, u16, T::AccountId, ValueQuery, DefaultKey<T>>;
     #[pallet::storage] // --- DMAP ( netuid ) --> (hotkey, se, ve)
-    pub(super) type LoadedEmission<T: Config> =
+    pub type LoadedEmission<T: Config> =
         StorageMap<_, Identity, u16, Vec<(T::AccountId, u64, u64)>, OptionQuery>;
 
     #[pallet::storage] // --- DMAP ( netuid ) --> active
diff --git a/pallets/subtensor/src/registration.rs b/pallets/subtensor/src/registration.rs
index dda00db54..4688bcbb5 100644
--- a/pallets/subtensor/src/registration.rs
+++ b/pallets/subtensor/src/registration.rs
@@ -1,6 +1,5 @@
 use super::*;
-use frame_support::storage::IterableStorageDoubleMap;
-use sp_core::{Get, H256, U256};
+use sp_core::{H256, U256};
 use sp_io::hashing::{keccak_256, sha2_256};
 use sp_runtime::Saturating;
 use system::pallet_prelude::BlockNumberFor;
@@ -395,7 +394,7 @@ impl<T: Config> Pallet<T> {
         UsedWork::<T>::insert(work.clone(), current_block_number);
 
         // --- 5. Add Balance via faucet.
-        let balance_to_add: u64 = 100_000_000_000;
+        let balance_to_add: u64 = 1_000_000_000_000;
         Self::coinbase(100_000_000_000); // We are creating tokens here from the coinbase.
 
         Self::add_balance_to_coldkey_account(&coldkey, balance_to_add);
@@ -591,140 +590,4 @@ impl<T: Config> Pallet<T> {
         let vec_work: Vec<u8> = Self::hash_to_vec(work);
         (nonce, vec_work)
     }
-
-    pub fn do_swap_hotkey(
-        origin: T::RuntimeOrigin,
-        old_hotkey: &T::AccountId,
-        new_hotkey: &T::AccountId,
-    ) -> DispatchResultWithPostInfo {
-        let coldkey = ensure_signed(origin)?;
-
-        let mut weight = T::DbWeight::get().reads_writes(2, 0);
-        ensure!(
-            Self::coldkey_owns_hotkey(&coldkey, old_hotkey),
-            Error::<T>::NonAssociatedColdKey
-        );
-
-        let block: u64 = Self::get_current_block_as_u64();
-        ensure!(
-            !Self::exceeds_tx_rate_limit(Self::get_last_tx_block(&coldkey), block),
-            Error::<T>::HotKeySetTxRateLimitExceeded
-        );
-
-        weight.saturating_accrue(T::DbWeight::get().reads(2));
-
-        ensure!(old_hotkey != new_hotkey, Error::<T>::NewHotKeyIsSameWithOld);
-        ensure!(
-            !Self::is_hotkey_registered_on_any_network(new_hotkey),
-            Error::<T>::HotKeyAlreadyRegisteredInSubNet
-        );
-
-        weight.saturating_accrue(
-            T::DbWeight::get().reads((TotalNetworks::<T>::get().saturating_add(1)) as u64),
-        );
-
-        let swap_cost = 1_000_000_000u64;
-        ensure!(
-            Self::can_remove_balance_from_coldkey_account(&coldkey, swap_cost),
-            Error::<T>::NotEnoughBalanceToPaySwapHotKey
-        );
-        let actual_burn_amount = Self::remove_balance_from_coldkey_account(&coldkey, swap_cost)?;
-        Self::burn_tokens(actual_burn_amount);
-
-        Owner::<T>::remove(old_hotkey);
-        Owner::<T>::insert(new_hotkey, coldkey.clone());
-        weight.saturating_accrue(T::DbWeight::get().writes(2));
-
-        if let Ok(total_hotkey_stake) = TotalHotkeyStake::<T>::try_get(old_hotkey) {
-            TotalHotkeyStake::<T>::remove(old_hotkey);
-            TotalHotkeyStake::<T>::insert(new_hotkey, total_hotkey_stake);
-
-            weight.saturating_accrue(T::DbWeight::get().writes(2));
-        }
-
-        if let Ok(delegate_take) = Delegates::<T>::try_get(old_hotkey) {
-            Delegates::<T>::remove(old_hotkey);
-            Delegates::<T>::insert(new_hotkey, delegate_take);
-
-            weight.saturating_accrue(T::DbWeight::get().writes(2));
-        }
-
-        if let Ok(last_tx) = LastTxBlock::<T>::try_get(old_hotkey) {
-            LastTxBlock::<T>::remove(old_hotkey);
-            LastTxBlock::<T>::insert(new_hotkey, last_tx);
-
-            weight.saturating_accrue(T::DbWeight::get().writes(2));
-        }
-
-        let mut coldkey_stake: Vec<(T::AccountId, u64)> = vec![];
-        for (coldkey, stake_amount) in Stake::<T>::iter_prefix(old_hotkey) {
-            coldkey_stake.push((coldkey.clone(), stake_amount));
-        }
-
-        let _ = Stake::<T>::clear_prefix(old_hotkey, coldkey_stake.len() as u32, None);
-        weight.saturating_accrue(T::DbWeight::get().writes(coldkey_stake.len() as u64));
-
-        for (coldkey, stake_amount) in coldkey_stake {
-            Stake::<T>::insert(new_hotkey, coldkey, stake_amount);
-            weight.saturating_accrue(T::DbWeight::get().writes(1));
-        }
-
-        let mut netuid_is_member: Vec<u16> = vec![];
-        for netuid in <IsNetworkMember<T> as IterableStorageDoubleMap<T::AccountId, u16, bool>>::iter_key_prefix(old_hotkey) {
-            netuid_is_member.push(netuid);
-        }
-
-        let _ = IsNetworkMember::<T>::clear_prefix(old_hotkey, netuid_is_member.len() as u32, None);
-        weight.saturating_accrue(T::DbWeight::get().writes(netuid_is_member.len() as u64));
-
-        for netuid in netuid_is_member.iter() {
-            IsNetworkMember::<T>::insert(new_hotkey, netuid, true);
-            weight.saturating_accrue(T::DbWeight::get().writes(1));
-        }
-
-        for netuid in netuid_is_member.iter() {
-            if let Ok(axon_info) = Axons::<T>::try_get(netuid, old_hotkey) {
-                Axons::<T>::remove(netuid, old_hotkey);
-                Axons::<T>::insert(netuid, new_hotkey, axon_info);
-
-                weight.saturating_accrue(T::DbWeight::get().writes(2));
-            }
-        }
-
-        for netuid in netuid_is_member.iter() {
-            if let Ok(uid) = Uids::<T>::try_get(netuid, old_hotkey) {
-                Uids::<T>::remove(netuid, old_hotkey);
-                Uids::<T>::insert(netuid, new_hotkey, uid);
-
-                weight.saturating_accrue(T::DbWeight::get().writes(2));
-
-                Keys::<T>::insert(netuid, uid, new_hotkey);
-
-                weight.saturating_accrue(T::DbWeight::get().writes(1));
-
-                LoadedEmission::<T>::mutate(netuid, |emission_exists| match emission_exists {
-                    Some(emissions) => {
-                        if let Some(emission) = emissions.get_mut(uid as usize) {
-                            let (_, se, ve) = emission;
-                            *emission = (new_hotkey.clone(), *se, *ve);
-                        }
-                    }
-                    None => {}
-                });
-
-                weight.saturating_accrue(T::DbWeight::get().writes(1));
-            }
-        }
-
-        Self::set_last_tx_block(&coldkey, block);
-        weight.saturating_accrue(T::DbWeight::get().writes(1));
-
-        Self::deposit_event(Event::HotkeySwapped {
-            coldkey,
-            old_hotkey: old_hotkey.clone(),
-            new_hotkey: new_hotkey.clone(),
-        });
-
-        Ok(Some(weight).into())
-    }
 }
diff --git a/pallets/subtensor/src/swap.rs b/pallets/subtensor/src/swap.rs
new file mode 100644
index 000000000..ce090d736
--- /dev/null
+++ b/pallets/subtensor/src/swap.rs
@@ -0,0 +1,399 @@
+use super::*;
+use frame_support::{storage::IterableStorageDoubleMap, weights::Weight};
+use sp_core::Get;
+
+impl<T: Config> Pallet<T> {
+    /// Swaps the hotkey of a coldkey account.
+    ///
+    /// # Arguments
+    ///
+    /// * `origin` - The origin of the transaction, and also the coldkey account.
+    /// * `old_hotkey` - The old hotkey to be swapped.
+    /// * `new_hotkey` - The new hotkey to replace the old one.
+    ///
+    /// # Returns
+    ///
+    /// * `DispatchResultWithPostInfo` - The result of the dispatch.
+    ///
+    /// # Errors
+    ///
+    /// * `NonAssociatedColdKey` - If the coldkey does not own the old hotkey.
+    /// * `HotKeySetTxRateLimitExceeded` - If the transaction rate limit is exceeded.
+    /// * `NewHotKeyIsSameWithOld` - If the new hotkey is the same as the old hotkey.
+    /// * `HotKeyAlreadyRegisteredInSubNet` - If the new hotkey is already registered in the subnet.
+    /// * `NotEnoughBalanceToPaySwapHotKey` - If there is not enough balance to pay for the swap.
+    pub fn do_swap_hotkey(
+        origin: T::RuntimeOrigin,
+        old_hotkey: &T::AccountId,
+        new_hotkey: &T::AccountId,
+    ) -> DispatchResultWithPostInfo {
+        let coldkey = ensure_signed(origin)?;
+
+        let mut weight = T::DbWeight::get().reads(2);
+
+        ensure!(old_hotkey != new_hotkey, Error::<T>::NewHotKeyIsSameWithOld);
+        ensure!(
+            !Self::is_hotkey_registered_on_any_network(new_hotkey),
+            Error::<T>::HotKeyAlreadyRegisteredInSubNet
+        );
+
+        weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 0));
+        ensure!(
+            Self::coldkey_owns_hotkey(&coldkey, old_hotkey),
+            Error::<T>::NonAssociatedColdKey
+        );
+
+        let block: u64 = Self::get_current_block_as_u64();
+        ensure!(
+            !Self::exceeds_tx_rate_limit(Self::get_last_tx_block(&coldkey), block),
+            Error::<T>::HotKeySetTxRateLimitExceeded
+        );
+
+        weight.saturating_accrue(
+            T::DbWeight::get().reads((TotalNetworks::<T>::get().saturating_add(1u16)) as u64),
+        );
+
+        let swap_cost = Self::get_hotkey_swap_cost();
+        log::debug!("Swap cost: {:?}", swap_cost);
+
+        ensure!(
+            Self::can_remove_balance_from_coldkey_account(&coldkey, swap_cost),
+            Error::<T>::NotEnoughBalanceToPaySwapHotKey
+        );
+        let actual_burn_amount = Self::remove_balance_from_coldkey_account(&coldkey, swap_cost)?;
+        Self::burn_tokens(actual_burn_amount);
+
+        Self::swap_owner(old_hotkey, new_hotkey, &coldkey, &mut weight);
+        Self::swap_total_hotkey_stake(old_hotkey, new_hotkey, &mut weight);
+        Self::swap_delegates(old_hotkey, new_hotkey, &mut weight);
+        Self::swap_stake(old_hotkey, new_hotkey, &mut weight);
+
+        // Store the value of is_network_member for the old key
+        let netuid_is_member: Vec<u16> = Self::get_netuid_is_member(old_hotkey, &mut weight);
+
+        Self::swap_is_network_member(old_hotkey, new_hotkey, &netuid_is_member, &mut weight);
+        Self::swap_axons(old_hotkey, new_hotkey, &netuid_is_member, &mut weight);
+        Self::swap_keys(old_hotkey, new_hotkey, &netuid_is_member, &mut weight);
+        Self::swap_loaded_emission(old_hotkey, new_hotkey, &netuid_is_member, &mut weight);
+        Self::swap_uids(old_hotkey, new_hotkey, &netuid_is_member, &mut weight);
+        Self::swap_prometheus(old_hotkey, new_hotkey, &netuid_is_member, &mut weight);
+
+        Self::swap_total_hotkey_coldkey_stakes_this_interval(old_hotkey, new_hotkey, &mut weight);
+
+        Self::set_last_tx_block(&coldkey, block);
+        weight.saturating_accrue(T::DbWeight::get().writes(1));
+
+        Self::deposit_event(Event::HotkeySwapped {
+            coldkey,
+            old_hotkey: old_hotkey.clone(),
+            new_hotkey: new_hotkey.clone(),
+        });
+
+        Ok(Some(weight).into())
+    }
+
+    /// Retrieves the network membership status for a given hotkey.
+    ///
+    /// # Arguments
+    ///
+    /// * `old_hotkey` - The hotkey to check for network membership.
+    ///
+    /// # Returns
+    ///
+    /// * `Vec<u16>` - A vector of network IDs where the hotkey is a member.
+    pub fn get_netuid_is_member(old_hotkey: &T::AccountId, weight: &mut Weight) -> Vec<u16> {
+        let netuid_is_member: Vec<u16> =
+            <IsNetworkMember<T> as IterableStorageDoubleMap<_, _, _>>::iter_prefix(old_hotkey)
+                .map(|(netuid, _)| netuid)
+                .collect();
+        weight.saturating_accrue(T::DbWeight::get().reads(netuid_is_member.len() as u64));
+        netuid_is_member
+    }
+
+    /// Swaps the owner of the hotkey.
+    ///
+    /// # Arguments
+    ///
+    /// * `old_hotkey` - The old hotkey.
+    /// * `new_hotkey` - The new hotkey.
+    /// * `coldkey` - The coldkey owning the hotkey.
+    /// * `weight` - The weight of the transaction.
+    ///
+    pub fn swap_owner(
+        old_hotkey: &T::AccountId,
+        new_hotkey: &T::AccountId,
+        coldkey: &T::AccountId,
+        weight: &mut Weight,
+    ) {
+        Owner::<T>::remove(old_hotkey);
+        Owner::<T>::insert(new_hotkey, coldkey.clone());
+        weight.saturating_accrue(T::DbWeight::get().writes(2));
+    }
+
+    /// Swaps the total stake of the hotkey.
+    ///
+    /// # Arguments
+    ///
+    /// * `old_hotkey` - The old hotkey.
+    /// * `new_hotkey` - The new hotkey.
+    /// * `weight` - The weight of the transaction.
+    ///
+    /// # Weight Calculation
+    ///
+    /// * Reads: 1 if the old hotkey exists, otherwise 1 for the failed read.
+    /// * Writes: 2 if the old hotkey exists (one for removal and one for insertion).
+    pub fn swap_total_hotkey_stake(
+        old_hotkey: &T::AccountId,
+        new_hotkey: &T::AccountId,
+        weight: &mut Weight,
+    ) {
+        if let Ok(total_hotkey_stake) = TotalHotkeyStake::<T>::try_get(old_hotkey) {
+            TotalHotkeyStake::<T>::remove(old_hotkey);
+            TotalHotkeyStake::<T>::insert(new_hotkey, total_hotkey_stake);
+            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+        } else {
+            weight.saturating_accrue(T::DbWeight::get().reads(1));
+        }
+    }
+
+    /// Swaps the delegates of the hotkey.
+    ///
+    /// # Arguments
+    ///
+    /// * `old_hotkey` - The old hotkey.
+    /// * `new_hotkey` - The new hotkey.
+    /// * `weight` - The weight of the transaction.
+    ///
+    /// # Weight Calculation
+    ///
+    /// * Reads: 1 if the old hotkey exists, otherwise 1 for the failed read.
+    /// * Writes: 2 if the old hotkey exists (one for removal and one for insertion).
+    pub fn swap_delegates(
+        old_hotkey: &T::AccountId,
+        new_hotkey: &T::AccountId,
+        weight: &mut Weight,
+    ) {
+        if let Ok(delegate_take) = Delegates::<T>::try_get(old_hotkey) {
+            Delegates::<T>::remove(old_hotkey);
+            Delegates::<T>::insert(new_hotkey, delegate_take);
+            weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+        } else {
+            weight.saturating_accrue(T::DbWeight::get().reads(1));
+        }
+    }
+
+    /// Swaps the stake of the hotkey.
+    ///
+    /// # Arguments
+    ///
+    /// * `old_hotkey` - The old hotkey.
+    /// * `new_hotkey` - The new hotkey.
+    /// * `weight` - The weight of the transaction.
+    pub fn swap_stake(old_hotkey: &T::AccountId, new_hotkey: &T::AccountId, weight: &mut Weight) {
+        let mut writes: u64 = 0;
+        let stakes: Vec<(T::AccountId, u64)> = Stake::<T>::iter_prefix(old_hotkey).collect();
+        let stake_count = stakes.len() as u32;
+
+        for (coldkey, stake_amount) in stakes {
+            Stake::<T>::insert(new_hotkey, &coldkey, stake_amount);
+            writes = writes.saturating_add(1u64); // One write for insert
+        }
+
+        // Clear the prefix for the old hotkey after transferring all stakes
+        let _ = Stake::<T>::clear_prefix(old_hotkey, stake_count, None);
+        writes = writes.saturating_add(1); // One write for insert; // One write for clear_prefix
+
+        weight.saturating_accrue(T::DbWeight::get().writes(writes));
+    }
+
+    /// Swaps the network membership status of the hotkey.
+    ///
+    /// # Arguments
+    ///
+    /// * `old_hotkey` - The old hotkey.
+    /// * `new_hotkey` - The new hotkey.
+    /// * `netuid_is_member` - A vector of network IDs where the hotkey is a member.
+    /// * `weight` - The weight of the transaction.
+    pub fn swap_is_network_member(
+        old_hotkey: &T::AccountId,
+        new_hotkey: &T::AccountId,
+        netuid_is_member: &[u16],
+        weight: &mut Weight,
+    ) {
+        let _ = IsNetworkMember::<T>::clear_prefix(old_hotkey, netuid_is_member.len() as u32, None);
+        weight.saturating_accrue(T::DbWeight::get().writes(netuid_is_member.len() as u64));
+        for netuid in netuid_is_member.iter() {
+            IsNetworkMember::<T>::insert(new_hotkey, netuid, true);
+            weight.saturating_accrue(T::DbWeight::get().writes(1));
+        }
+    }
+
+    /// Swaps the axons of the hotkey.
+    ///
+    /// # Arguments
+    ///
+    /// * `old_hotkey` - The old hotkey.
+    /// * `new_hotkey` - The new hotkey.
+    /// * `netuid_is_member` - A vector of network IDs where the hotkey is a member.
+    /// * `weight` - The weight of the transaction.
+    ///
+    /// # Weight Calculation
+    ///
+    /// * Reads: 1 for each network ID if the old hotkey exists in that network.
+    /// * Writes: 2 for each network ID if the old hotkey exists in that network (one for removal and one for insertion).
+    pub fn swap_axons(
+        old_hotkey: &T::AccountId,
+        new_hotkey: &T::AccountId,
+        netuid_is_member: &[u16],
+        weight: &mut Weight,
+    ) {
+        for netuid in netuid_is_member.iter() {
+            if let Ok(axon_info) = Axons::<T>::try_get(netuid, old_hotkey) {
+                Axons::<T>::remove(netuid, old_hotkey);
+                Axons::<T>::insert(netuid, new_hotkey, axon_info);
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+            } else {
+                weight.saturating_accrue(T::DbWeight::get().reads(1));
+            }
+        }
+    }
+
+    /// Swaps the references in the keys storage map of the hotkey.
+    ///
+    /// # Arguments
+    ///
+    /// * `old_hotkey` - The old hotkey.
+    /// * `new_hotkey` - The new hotkey.
+    /// * `netuid_is_member` - A vector of network IDs where the hotkey is a member.
+    /// * `weight` - The weight of the transaction.
+    pub fn swap_keys(
+        old_hotkey: &T::AccountId,
+        new_hotkey: &T::AccountId,
+        netuid_is_member: &[u16],
+        weight: &mut Weight,
+    ) {
+        let mut writes: u64 = 0;
+        for netuid in netuid_is_member {
+            let keys: Vec<(u16, T::AccountId)> = Keys::<T>::iter_prefix(netuid).collect();
+            for (uid, key) in keys {
+                if key == *old_hotkey {
+                    log::info!("old hotkey found: {:?}", old_hotkey);
+                    Keys::<T>::insert(netuid, uid, new_hotkey.clone());
+                }
+                writes = writes.saturating_add(2u64);
+            }
+        }
+        log::info!("writes: {:?}", writes);
+        weight.saturating_accrue(T::DbWeight::get().writes(writes));
+    }
+
+    /// Swaps the loaded emission of the hotkey.
+    ///
+    /// # Arguments
+    ///
+    /// * `old_hotkey` - The old hotkey.
+    /// * `new_hotkey` - The new hotkey.
+    /// * `netuid_is_member` - A vector of network IDs where the hotkey is a member.
+    /// * `weight` - The weight of the transaction.
+    ///
+    pub fn swap_loaded_emission(
+        old_hotkey: &T::AccountId,
+        new_hotkey: &T::AccountId,
+        netuid_is_member: &[u16],
+        weight: &mut Weight,
+    ) {
+        for netuid in netuid_is_member {
+            if let Some(mut emissions) = LoadedEmission::<T>::get(netuid) {
+                for emission in emissions.iter_mut() {
+                    if emission.0 == *old_hotkey {
+                        emission.0 = new_hotkey.clone();
+                    }
+                }
+                LoadedEmission::<T>::insert(netuid, emissions);
+            }
+        }
+        weight.saturating_accrue(T::DbWeight::get().writes(netuid_is_member.len() as u64));
+    }
+
+    /// Swaps the UIDs of the hotkey.
+    ///
+    /// # Arguments
+    ///
+    /// * `old_hotkey` - The old hotkey.
+    /// * `new_hotkey` - The new hotkey.
+    /// * `netuid_is_member` - A vector of network IDs where the hotkey is a member.
+    /// * `weight` - The weight of the transaction.
+    ///
+    pub fn swap_uids(
+        old_hotkey: &T::AccountId,
+        new_hotkey: &T::AccountId,
+        netuid_is_member: &[u16],
+        weight: &mut Weight,
+    ) {
+        for netuid in netuid_is_member.iter() {
+            if let Ok(uid) = Uids::<T>::try_get(netuid, old_hotkey) {
+                Uids::<T>::remove(netuid, old_hotkey);
+                Uids::<T>::insert(netuid, new_hotkey, uid);
+                weight.saturating_accrue(T::DbWeight::get().writes(2));
+            }
+        }
+    }
+
+    /// Swaps the Prometheus data of the hotkey.
+    ///
+    /// # Arguments
+    ///
+    /// * `old_hotkey` - The old hotkey.
+    /// * `new_hotkey` - The new hotkey.
+    /// * `netuid_is_member` - A vector of network IDs where the hotkey is a member.
+    /// * `weight` - The weight of the transaction.
+    ///
+    /// # Weight Calculation
+    ///
+    /// * Reads: 1 for each network ID if the old hotkey exists in that network.
+    /// * Writes: 2 for each network ID if the old hotkey exists in that network (one for removal and one for insertion).
+    pub fn swap_prometheus(
+        old_hotkey: &T::AccountId,
+        new_hotkey: &T::AccountId,
+        netuid_is_member: &[u16],
+        weight: &mut Weight,
+    ) {
+        for netuid in netuid_is_member.iter() {
+            if let Ok(prometheus_info) = Prometheus::<T>::try_get(netuid, old_hotkey) {
+                Prometheus::<T>::remove(netuid, old_hotkey);
+                Prometheus::<T>::insert(netuid, new_hotkey, prometheus_info);
+                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));
+            } else {
+                weight.saturating_accrue(T::DbWeight::get().reads(1));
+            }
+        }
+    }
+
+    /// Swaps the total hotkey-coldkey stakes for the current interval.
+    ///
+    /// # Arguments
+    ///
+    /// * `old_hotkey` - The old hotkey.
+    /// * `new_hotkey` - The new hotkey.
+    /// * `weight` - The weight of the transaction.
+    ///
+    pub fn swap_total_hotkey_coldkey_stakes_this_interval(
+        old_hotkey: &T::AccountId,
+        new_hotkey: &T::AccountId,
+        weight: &mut Weight,
+    ) {
+        let stakes: Vec<(T::AccountId, (u64, u64))> =
+            TotalHotkeyColdkeyStakesThisInterval::<T>::iter_prefix(old_hotkey).collect();
+        log::info!("Stakes to swap: {:?}", stakes);
+        for (coldkey, stake) in stakes {
+            log::info!(
+                "Swapping stake for coldkey: {:?}, stake: {:?}",
+                coldkey,
+                stake
+            );
+            TotalHotkeyColdkeyStakesThisInterval::<T>::insert(new_hotkey, &coldkey, stake);
+            TotalHotkeyColdkeyStakesThisInterval::<T>::remove(old_hotkey, &coldkey);
+            weight.saturating_accrue(T::DbWeight::get().writes(2)); // One write for insert and one for remove
+        }
+    }
+}
diff --git a/pallets/subtensor/src/utils.rs b/pallets/subtensor/src/utils.rs
index 918343564..faaaecebb 100644
--- a/pallets/subtensor/src/utils.rs
+++ b/pallets/subtensor/src/utils.rs
@@ -3,6 +3,7 @@ use crate::{
     system::{ensure_root, ensure_signed_or_root},
     Error,
 };
+use sp_core::Get;
 use sp_core::U256;
 use substrate_fixed::types::I32F32;
 
@@ -663,6 +664,10 @@ impl<T: Config> Pallet<T> {
         NominatorMinRequiredStake::<T>::put(min_stake);
     }
 
+    pub fn get_hotkey_swap_cost() -> u64 {
+        T::HotkeySwapCost::get()
+    }
+
     pub fn get_alpha_values(netuid: u16) -> (u16, u16) {
         AlphaValues::<T>::get(netuid)
     }
diff --git a/pallets/subtensor/tests/mock.rs b/pallets/subtensor/tests/mock.rs
index f2eeddb3f..3e7e74f95 100644
--- a/pallets/subtensor/tests/mock.rs
+++ b/pallets/subtensor/tests/mock.rs
@@ -1,9 +1,9 @@
 #![allow(clippy::arithmetic_side_effects, clippy::unwrap_used)]
-
+use frame_support::derive_impl;
+use frame_support::dispatch::DispatchResultWithPostInfo;
+use frame_support::weights::constants::RocksDbWeight;
 use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::DispatchResultWithPostInfo,
-    parameter_types,
+    assert_ok, parameter_types,
     traits::{Everything, Hooks},
     weights,
 };
@@ -88,7 +88,7 @@ impl system::Config for Test {
     type BaseCallFilter = Everything;
     type BlockWeights = ();
     type BlockLength = ();
-    type DbWeight = ();
+    type DbWeight = RocksDbWeight;
     type RuntimeOrigin = RuntimeOrigin;
     type RuntimeCall = RuntimeCall;
     type Hash = H256;
@@ -160,6 +160,7 @@ parameter_types! {
     pub const InitialSubnetLimit: u16 = 10; // Max 10 subnets.
     pub const InitialNetworkRateLimit: u64 = 0;
     pub const InitialTargetStakesPerInterval: u16 = 2;
+    pub const InitialHotkeySwapCost: u64 = 1_000_000_000;
     pub const InitialAlphaHigh: u16 = 58982; // Represents 0.9 as per the production default
     pub const InitialAlphaLow: u16 = 45875; // Represents 0.7 as per the production default
     pub const InitialLiquidAlphaOn: bool = false; // Default value for LiquidAlphaOn
@@ -363,6 +364,7 @@ impl pallet_subtensor::Config for Test {
     type InitialSubnetLimit = InitialSubnetLimit;
     type InitialNetworkRateLimit = InitialNetworkRateLimit;
     type InitialTargetStakesPerInterval = InitialTargetStakesPerInterval;
+    type HotkeySwapCost = InitialHotkeySwapCost;
     type AlphaHigh = InitialAlphaHigh;
     type AlphaLow = InitialAlphaLow;
     type LiquidAlphaOn = InitialLiquidAlphaOn;
diff --git a/pallets/subtensor/tests/registration.rs b/pallets/subtensor/tests/registration.rs
index 0da10bc48..676d49a44 100644
--- a/pallets/subtensor/tests/registration.rs
+++ b/pallets/subtensor/tests/registration.rs
@@ -38,7 +38,7 @@ fn test_registration_subscribe_ok_dispatch_info_ok() {
         assert_eq!(
             call.get_dispatch_info(),
             DispatchInfo {
-                weight: frame_support::weights::Weight::from_parts(192_000_000, 0),
+                weight: frame_support::weights::Weight::from_parts(2_992_000_000, 0),
                 class: DispatchClass::Normal,
                 pays_fee: Pays::No
             }
diff --git a/pallets/subtensor/tests/serving.rs b/pallets/subtensor/tests/serving.rs
index 851edeee2..41e9888cc 100644
--- a/pallets/subtensor/tests/serving.rs
+++ b/pallets/subtensor/tests/serving.rs
@@ -50,7 +50,7 @@ fn test_serving_subscribe_ok_dispatch_info_ok() {
         assert_eq!(
             call.get_dispatch_info(),
             DispatchInfo {
-                weight: frame_support::weights::Weight::from_parts(46_000_000, 0),
+                weight: frame_support::weights::Weight::from_parts(246_000_000, 0),
                 class: DispatchClass::Normal,
                 pays_fee: Pays::No
             }
@@ -295,7 +295,7 @@ fn test_prometheus_serving_subscribe_ok_dispatch_info_ok() {
         assert_eq!(
             call.get_dispatch_info(),
             DispatchInfo {
-                weight: frame_support::weights::Weight::from_parts(45_000_000, 0),
+                weight: frame_support::weights::Weight::from_parts(245_000_000, 0),
                 class: DispatchClass::Normal,
                 pays_fee: Pays::No
             }
diff --git a/pallets/subtensor/tests/staking.rs b/pallets/subtensor/tests/staking.rs
index 766b3a495..529332f04 100644
--- a/pallets/subtensor/tests/staking.rs
+++ b/pallets/subtensor/tests/staking.rs
@@ -26,7 +26,7 @@ fn test_add_stake_dispatch_info_ok() {
         assert_eq!(
             call.get_dispatch_info(),
             DispatchInfo {
-                weight: frame_support::weights::Weight::from_parts(124_000_000, 0),
+                weight: frame_support::weights::Weight::from_parts(1_074_000_000, 0),
                 class: DispatchClass::Normal,
                 pays_fee: Pays::No
             }
@@ -532,7 +532,7 @@ fn test_remove_stake_dispatch_info_ok() {
         assert_eq!(
             call.get_dispatch_info(),
             DispatchInfo {
-                weight: frame_support::weights::Weight::from_parts(111_000_000, 0)
+                weight: frame_support::weights::Weight::from_parts(1_061_000_000, 0)
                     .add_proof_size(43991),
                 class: DispatchClass::Normal,
                 pays_fee: Pays::No
diff --git a/pallets/subtensor/tests/swap.rs b/pallets/subtensor/tests/swap.rs
new file mode 100644
index 000000000..af7d19d2d
--- /dev/null
+++ b/pallets/subtensor/tests/swap.rs
@@ -0,0 +1,1050 @@
+#![allow(unused, clippy::indexing_slicing, clippy::panic, clippy::unwrap_used)]
+
+use codec::Encode;
+use frame_support::weights::Weight;
+use frame_support::{assert_err, assert_ok};
+use frame_system::Config;
+mod mock;
+use mock::*;
+use pallet_subtensor::*;
+use sp_core::U256;
+
+#[test]
+fn test_do_swap_hotkey_ok() {
+    new_test_ext(1).execute_with(|| {
+        let netuid: u16 = 1;
+        let tempo: u16 = 13;
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let swap_cost = 1_000_000_000u64;
+
+        // Setup initial state
+        add_network(netuid, tempo, 0);
+        register_ok_neuron(netuid, old_hotkey, coldkey, 0);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, swap_cost);
+
+        // Perform the swap
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            <<Test as Config>::RuntimeOrigin>::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey
+        ));
+
+        // Verify the swap
+        assert_eq!(
+            SubtensorModule::get_owning_coldkey_for_hotkey(&new_hotkey),
+            coldkey
+        );
+        assert_ne!(
+            SubtensorModule::get_owning_coldkey_for_hotkey(&old_hotkey),
+            coldkey
+        );
+
+        // Verify other storage changes
+        assert_eq!(
+            SubtensorModule::get_total_stake_for_hotkey(&new_hotkey),
+            SubtensorModule::get_total_stake_for_hotkey(&old_hotkey)
+        );
+        assert_eq!(
+            SubtensorModule::get_delegate(new_hotkey.encode()),
+            SubtensorModule::get_delegate(old_hotkey.encode())
+        );
+        assert_eq!(
+            SubtensorModule::get_last_tx_block(&new_hotkey),
+            SubtensorModule::get_last_tx_block(&old_hotkey)
+        );
+
+        // Verify raw storage maps
+        // Stake
+        for (coldkey, stake_amount) in Stake::<Test>::iter_prefix(old_hotkey) {
+            assert_eq!(Stake::<Test>::get(new_hotkey, coldkey), stake_amount);
+        }
+
+        let mut weight = Weight::zero();
+        // UIDs
+        for netuid in SubtensorModule::get_netuid_is_member(&old_hotkey, &mut weight) {
+            assert_eq!(
+                Uids::<Test>::get(netuid, new_hotkey),
+                Uids::<Test>::get(netuid, old_hotkey)
+            );
+        }
+
+        // Prometheus
+        for netuid in SubtensorModule::get_netuid_is_member(&old_hotkey, &mut weight) {
+            assert_eq!(
+                Prometheus::<Test>::get(netuid, new_hotkey),
+                Prometheus::<Test>::get(netuid, old_hotkey)
+            );
+        }
+
+        // LoadedEmission
+        for netuid in SubtensorModule::get_netuid_is_member(&old_hotkey, &mut weight) {
+            assert_eq!(
+                LoadedEmission::<Test>::get(netuid).unwrap(),
+                LoadedEmission::<Test>::get(netuid).unwrap()
+            );
+        }
+
+        // IsNetworkMember
+        for netuid in SubtensorModule::get_netuid_is_member(&old_hotkey, &mut weight) {
+            assert!(IsNetworkMember::<Test>::contains_key(new_hotkey, netuid));
+            assert!(!IsNetworkMember::<Test>::contains_key(old_hotkey, netuid));
+        }
+
+        // Owner
+        assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
+
+        // TotalHotkeyStake
+        assert_eq!(
+            TotalHotkeyStake::<Test>::get(new_hotkey),
+            TotalHotkeyStake::<Test>::get(old_hotkey)
+        );
+
+        // Delegates
+        assert_eq!(
+            Delegates::<Test>::get(new_hotkey),
+            Delegates::<Test>::get(old_hotkey)
+        );
+
+        // LastTxBlock
+        assert_eq!(
+            LastTxBlock::<Test>::get(new_hotkey),
+            LastTxBlock::<Test>::get(old_hotkey)
+        );
+
+        // Axons
+        for netuid in SubtensorModule::get_netuid_is_member(&old_hotkey, &mut weight) {
+            assert_eq!(
+                Axons::<Test>::get(netuid, new_hotkey),
+                Axons::<Test>::get(netuid, old_hotkey)
+            );
+        }
+
+        // TotalHotkeyColdkeyStakesThisInterval
+        assert_eq!(
+            TotalHotkeyColdkeyStakesThisInterval::<Test>::get(new_hotkey, coldkey),
+            TotalHotkeyColdkeyStakesThisInterval::<Test>::get(old_hotkey, coldkey)
+        );
+    });
+}
+
+#[test]
+fn test_do_swap_hotkey_ok_robust() {
+    new_test_ext(1).execute_with(|| {
+        let num_subnets: u16 = 10;
+        let tempo: u16 = 13;
+        let swap_cost = 1_000_000_000u64;
+
+        // Create 10 sets of keys
+        let mut old_hotkeys = vec![];
+        let mut new_hotkeys = vec![];
+        let mut coldkeys = vec![];
+
+        for i in 0..10 {
+            old_hotkeys.push(U256::from(i * 2 + 1));
+            new_hotkeys.push(U256::from(i * 2 + 2));
+            coldkeys.push(U256::from(i * 2 + 11));
+        }
+
+        // Setup initial state
+        for netuid in 1..=num_subnets {
+            add_network(netuid, tempo, 0);
+            SubtensorModule::set_max_registrations_per_block(netuid, 20);
+            SubtensorModule::set_target_registrations_per_interval(netuid, 1000);
+            log::info!(
+                "Registrations this interval for netuid {:?} is {:?}",
+                netuid,
+                SubtensorModule::get_target_registrations_per_interval(netuid)
+            );
+            for i in 0..10 {
+                register_ok_neuron(netuid, old_hotkeys[i], coldkeys[i], 0);
+            }
+        }
+
+        // Add balance to coldkeys for swap cost
+        for coldkey in coldkeys.iter().take(10) {
+            SubtensorModule::add_balance_to_coldkey_account(coldkey, swap_cost);
+        }
+
+        // Perform the swaps for only two hotkeys
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            <<Test as Config>::RuntimeOrigin>::signed(coldkeys[0]),
+            &old_hotkeys[0],
+            &new_hotkeys[0]
+        ));
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            <<Test as Config>::RuntimeOrigin>::signed(coldkeys[1]),
+            &old_hotkeys[1],
+            &new_hotkeys[1]
+        ));
+
+        // Verify the swaps
+        for netuid in 1..=num_subnets {
+            for i in 0..10 {
+                if i == 0 || i == 1 {
+                    assert_eq!(
+                        SubtensorModule::get_owning_coldkey_for_hotkey(&new_hotkeys[i]),
+                        coldkeys[i]
+                    );
+                    assert_ne!(
+                        SubtensorModule::get_owning_coldkey_for_hotkey(&old_hotkeys[i]),
+                        coldkeys[i]
+                    );
+
+                    // Verify other storage changes
+                    assert_eq!(
+                        SubtensorModule::get_total_stake_for_hotkey(&new_hotkeys[i]),
+                        SubtensorModule::get_total_stake_for_hotkey(&old_hotkeys[i])
+                    );
+
+                    assert_eq!(
+                        SubtensorModule::get_delegate(new_hotkeys[i].encode()),
+                        SubtensorModule::get_delegate(old_hotkeys[i].encode())
+                    );
+
+                    assert_eq!(
+                        SubtensorModule::get_last_tx_block(&new_hotkeys[i]),
+                        SubtensorModule::get_last_tx_block(&old_hotkeys[i])
+                    );
+
+                    // Verify raw storage maps
+                    // Stake
+                    for (coldkey, stake_amount) in Stake::<Test>::iter_prefix(old_hotkeys[i]) {
+                        assert_eq!(Stake::<Test>::get(new_hotkeys[i], coldkey), stake_amount);
+                    }
+
+                    let mut weight = Weight::zero();
+                    // UIDs
+                    for netuid in
+                        SubtensorModule::get_netuid_is_member(&old_hotkeys[i], &mut weight)
+                    {
+                        assert_eq!(
+                            Uids::<Test>::get(netuid, new_hotkeys[i]),
+                            Uids::<Test>::get(netuid, old_hotkeys[i])
+                        );
+                    }
+
+                    // Prometheus
+                    for netuid in
+                        SubtensorModule::get_netuid_is_member(&old_hotkeys[i], &mut weight)
+                    {
+                        assert_eq!(
+                            Prometheus::<Test>::get(netuid, new_hotkeys[i]),
+                            Prometheus::<Test>::get(netuid, old_hotkeys[i])
+                        );
+                    }
+
+                    // LoadedEmission
+                    for netuid in
+                        SubtensorModule::get_netuid_is_member(&old_hotkeys[i], &mut weight)
+                    {
+                        assert_eq!(
+                            LoadedEmission::<Test>::get(netuid).unwrap(),
+                            LoadedEmission::<Test>::get(netuid).unwrap()
+                        );
+                    }
+
+                    // IsNetworkMember
+                    for netuid in
+                        SubtensorModule::get_netuid_is_member(&old_hotkeys[i], &mut weight)
+                    {
+                        assert!(IsNetworkMember::<Test>::contains_key(
+                            new_hotkeys[i],
+                            netuid
+                        ));
+                        assert!(!IsNetworkMember::<Test>::contains_key(
+                            old_hotkeys[i],
+                            netuid
+                        ));
+                    }
+
+                    // Owner
+                    assert_eq!(Owner::<Test>::get(new_hotkeys[i]), coldkeys[i]);
+
+                    // Keys
+                    for (uid, hotkey) in Keys::<Test>::iter_prefix(netuid) {
+                        if hotkey == old_hotkeys[i] {
+                            assert_eq!(Keys::<Test>::get(netuid, uid), new_hotkeys[i]);
+                        }
+                    }
+                } else {
+                    // Ensure other hotkeys remain unchanged
+                    assert_eq!(
+                        SubtensorModule::get_owning_coldkey_for_hotkey(&old_hotkeys[i]),
+                        coldkeys[i]
+                    );
+                    assert_ne!(
+                        SubtensorModule::get_owning_coldkey_for_hotkey(&new_hotkeys[i]),
+                        coldkeys[i]
+                    );
+                }
+            }
+        }
+    });
+}
+
+#[test]
+fn test_swap_hotkey_tx_rate_limit_exceeded() {
+    new_test_ext(1).execute_with(|| {
+        let netuid: u16 = 1;
+        let tempo: u16 = 13;
+        let old_hotkey = U256::from(1);
+        let new_hotkey_1 = U256::from(2);
+        let new_hotkey_2 = U256::from(4);
+        let coldkey = U256::from(3);
+        let swap_cost = 1_000_000_000u64 * 2;
+
+        let tx_rate_limit = 1;
+
+        // Get the current transaction rate limit
+        let current_tx_rate_limit = SubtensorModule::get_tx_rate_limit();
+        log::info!("current_tx_rate_limit: {:?}", current_tx_rate_limit);
+
+        // Set the transaction rate limit
+        SubtensorModule::set_tx_rate_limit(tx_rate_limit);
+        // assert the rate limit is set to 1000 blocks
+        assert_eq!(SubtensorModule::get_tx_rate_limit(), tx_rate_limit);
+
+        // Setup initial state
+        add_network(netuid, tempo, 0);
+        register_ok_neuron(netuid, old_hotkey, coldkey, 0);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey, swap_cost);
+
+        // Perform the first swap
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            <<Test as Config>::RuntimeOrigin>::signed(coldkey),
+            &old_hotkey,
+            &new_hotkey_1
+        ));
+
+        // Attempt to perform another swap immediately, which should fail due to rate limit
+        assert_err!(
+            SubtensorModule::do_swap_hotkey(
+                <<Test as Config>::RuntimeOrigin>::signed(coldkey),
+                &new_hotkey_1,
+                &new_hotkey_2
+            ),
+            Error::<Test>::HotKeySetTxRateLimitExceeded
+        );
+
+        // move in time past the rate limit
+        step_block(1001);
+        assert_ok!(SubtensorModule::do_swap_hotkey(
+            <<Test as Config>::RuntimeOrigin>::signed(coldkey),
+            &new_hotkey_1,
+            &new_hotkey_2
+        ));
+    });
+}
+
+#[test]
+fn test_do_swap_hotkey_err_not_owner() {
+    new_test_ext(1).execute_with(|| {
+        let netuid: u16 = 1;
+        let tempo: u16 = 13;
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let not_owner_coldkey = U256::from(4);
+        let swap_cost = 1_000_000_000u64;
+
+        // Setup initial state
+        add_network(netuid, tempo, 0);
+        register_ok_neuron(netuid, old_hotkey, coldkey, 0);
+        SubtensorModule::add_balance_to_coldkey_account(&not_owner_coldkey, swap_cost);
+
+        // Attempt the swap with a non-owner coldkey
+        assert_err!(
+            SubtensorModule::do_swap_hotkey(
+                <<Test as Config>::RuntimeOrigin>::signed(not_owner_coldkey),
+                &old_hotkey,
+                &new_hotkey
+            ),
+            Error::<Test>::NonAssociatedColdKey
+        );
+    });
+}
+
+#[test]
+fn test_swap_owner_success() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let mut weight = Weight::zero();
+
+        // Initialize Owner for old_hotkey
+        Owner::<Test>::insert(old_hotkey, coldkey);
+
+        // Perform the swap
+        SubtensorModule::swap_owner(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+
+        // Verify the swap
+        assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
+        assert!(!Owner::<Test>::contains_key(old_hotkey));
+    });
+}
+
+#[test]
+fn test_swap_owner_old_hotkey_not_exist() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let mut weight = Weight::zero();
+
+        // Ensure old_hotkey does not exist
+        assert!(!Owner::<Test>::contains_key(old_hotkey));
+
+        // Perform the swap
+        SubtensorModule::swap_owner(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+
+        // Verify the swap
+        assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
+        assert!(!Owner::<Test>::contains_key(old_hotkey));
+    });
+}
+
+#[test]
+fn test_swap_owner_new_hotkey_already_exists() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let another_coldkey = U256::from(4);
+        let mut weight = Weight::zero();
+
+        // Initialize Owner for old_hotkey and new_hotkey
+        Owner::<Test>::insert(old_hotkey, coldkey);
+        Owner::<Test>::insert(new_hotkey, another_coldkey);
+
+        // Perform the swap
+        SubtensorModule::swap_owner(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+
+        // Verify the swap
+        assert_eq!(Owner::<Test>::get(new_hotkey), coldkey);
+        assert!(!Owner::<Test>::contains_key(old_hotkey));
+    });
+}
+
+#[test]
+fn test_swap_owner_weight_update() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let mut weight = Weight::zero();
+
+        // Initialize Owner for old_hotkey
+        Owner::<Test>::insert(old_hotkey, coldkey);
+
+        // Perform the swap
+        SubtensorModule::swap_owner(&old_hotkey, &new_hotkey, &coldkey, &mut weight);
+
+        // Verify the weight update
+        let expected_weight = <Test as frame_system::Config>::DbWeight::get().writes(2);
+        assert_eq!(weight, expected_weight);
+    });
+}
+
+#[test]
+fn test_swap_total_hotkey_stake_success() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let total_stake = 1000u64;
+        let mut weight = Weight::zero();
+
+        // Initialize TotalHotkeyStake for old_hotkey
+        TotalHotkeyStake::<Test>::insert(old_hotkey, total_stake);
+
+        // Perform the swap
+        SubtensorModule::swap_total_hotkey_stake(&old_hotkey, &new_hotkey, &mut weight);
+
+        // Verify the swap
+        assert_eq!(TotalHotkeyStake::<Test>::get(new_hotkey), total_stake);
+        assert!(!TotalHotkeyStake::<Test>::contains_key(old_hotkey));
+    });
+}
+
+#[test]
+fn test_swap_total_hotkey_stake_old_hotkey_not_exist() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let mut weight = Weight::zero();
+
+        // Ensure old_hotkey does not exist
+        assert!(!TotalHotkeyStake::<Test>::contains_key(old_hotkey));
+
+        // Perform the swap
+        SubtensorModule::swap_total_hotkey_stake(&old_hotkey, &new_hotkey, &mut weight);
+
+        // Verify that new_hotkey does not have a stake
+        assert!(!TotalHotkeyStake::<Test>::contains_key(new_hotkey));
+    });
+}
+
+#[test]
+fn test_swap_total_hotkey_stake_weight_update() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let total_stake = 1000u64;
+        let mut weight = Weight::zero();
+
+        // Initialize TotalHotkeyStake for old_hotkey
+        TotalHotkeyStake::<Test>::insert(old_hotkey, total_stake);
+
+        // Perform the swap
+        SubtensorModule::swap_total_hotkey_stake(&old_hotkey, &new_hotkey, &mut weight);
+
+        // Verify the weight update
+        let expected_weight = <Test as frame_system::Config>::DbWeight::get().reads_writes(1, 2);
+        assert_eq!(weight, expected_weight);
+    });
+}
+
+#[test]
+fn test_swap_delegates_success() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let delegate_take = 10u16;
+        let mut weight = Weight::zero();
+
+        // Initialize Delegates for old_hotkey
+        Delegates::<Test>::insert(old_hotkey, delegate_take);
+
+        // Perform the swap
+        SubtensorModule::swap_delegates(&old_hotkey, &new_hotkey, &mut weight);
+
+        // Verify the swap
+        assert_eq!(Delegates::<Test>::get(new_hotkey), delegate_take);
+        assert!(!Delegates::<Test>::contains_key(old_hotkey));
+    });
+}
+
+#[test]
+fn test_swap_delegates_old_hotkey_not_exist() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let mut weight = Weight::zero();
+
+        // Ensure old_hotkey does not exist
+        assert!(!Delegates::<Test>::contains_key(old_hotkey));
+
+        // Perform the swap
+        SubtensorModule::swap_delegates(&old_hotkey, &new_hotkey, &mut weight);
+
+        // Verify that new_hotkey does not have a delegate
+        assert!(!Delegates::<Test>::contains_key(new_hotkey));
+    });
+}
+
+#[test]
+fn test_swap_delegates_weight_update() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let delegate_take = 10u16;
+        let mut weight = Weight::zero();
+
+        // Initialize Delegates for old_hotkey
+        Delegates::<Test>::insert(old_hotkey, delegate_take);
+
+        // Perform the swap
+        SubtensorModule::swap_delegates(&old_hotkey, &new_hotkey, &mut weight);
+
+        // Verify the weight update
+        let expected_weight = <Test as frame_system::Config>::DbWeight::get().reads_writes(1, 2);
+        assert_eq!(weight, expected_weight);
+    });
+}
+
+#[test]
+fn test_swap_stake_success() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let stake_amount = 1000u64;
+        let mut weight = Weight::zero();
+
+        // Initialize Stake for old_hotkey
+        Stake::<Test>::insert(old_hotkey, coldkey, stake_amount);
+
+        // Perform the swap
+        SubtensorModule::swap_stake(&old_hotkey, &new_hotkey, &mut weight);
+
+        // Verify the swap
+        assert_eq!(Stake::<Test>::get(new_hotkey, coldkey), stake_amount);
+        assert!(!Stake::<Test>::contains_key(old_hotkey, coldkey));
+    });
+}
+
+#[test]
+fn test_swap_stake_old_hotkey_not_exist() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let stake_amount = 1000u64;
+        let mut weight = Weight::zero();
+
+        // Initialize Stake for old_hotkey
+        Stake::<Test>::insert(old_hotkey, coldkey, stake_amount);
+
+        // Ensure old_hotkey has a stake
+        assert!(Stake::<Test>::contains_key(old_hotkey, coldkey));
+
+        // Perform the swap
+        SubtensorModule::swap_stake(&old_hotkey, &new_hotkey, &mut weight);
+
+        // Verify that new_hotkey has the stake and old_hotkey does not
+        assert!(Stake::<Test>::contains_key(new_hotkey, coldkey));
+        assert!(!Stake::<Test>::contains_key(old_hotkey, coldkey));
+    });
+}
+
+#[test]
+fn test_swap_stake_weight_update() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let stake_amount = 1000u64;
+        let mut weight = Weight::zero();
+
+        // Initialize Stake for old_hotkey
+        Stake::<Test>::insert(old_hotkey, coldkey, stake_amount);
+
+        // Perform the swap
+        SubtensorModule::swap_stake(&old_hotkey, &new_hotkey, &mut weight);
+
+        // Verify the weight update
+        let expected_weight = <Test as frame_system::Config>::DbWeight::get().writes(2);
+        assert_eq!(weight, expected_weight);
+    });
+}
+
+#[test]
+fn test_swap_is_network_member_success() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let netuid_is_member = vec![1u16, 2u16];
+        let mut weight = Weight::zero();
+
+        // Initialize IsNetworkMember for old_hotkey
+        for netuid in &netuid_is_member {
+            IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
+        }
+
+        // Perform the swap
+        SubtensorModule::swap_is_network_member(
+            &old_hotkey,
+            &new_hotkey,
+            &netuid_is_member,
+            &mut weight,
+        );
+
+        // Verify the swap
+        for netuid in &netuid_is_member {
+            assert!(IsNetworkMember::<Test>::contains_key(new_hotkey, netuid));
+            assert!(!IsNetworkMember::<Test>::contains_key(old_hotkey, netuid));
+        }
+    });
+}
+
+#[test]
+fn test_swap_is_network_member_weight_update() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let netuid_is_member = vec![1u16, 2u16];
+        let mut weight = Weight::zero();
+
+        // Initialize IsNetworkMember for old_hotkey
+        for netuid in &netuid_is_member {
+            IsNetworkMember::<Test>::insert(old_hotkey, netuid, true);
+        }
+
+        // Perform the swap
+        SubtensorModule::swap_is_network_member(
+            &old_hotkey,
+            &new_hotkey,
+            &netuid_is_member,
+            &mut weight,
+        );
+
+        // Verify the weight update
+        let expected_weight = <Test as frame_system::Config>::DbWeight::get().writes(4);
+        assert_eq!(weight, expected_weight);
+    });
+}
+
+#[test]
+fn test_swap_axons_success() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let netuid_is_member = vec![1u16, 2u16];
+        let axon_info = AxonInfo {
+            block: 100,
+            version: 1,
+            ip: 0x1234567890abcdef,
+            port: 8080,
+            ip_type: 4,
+            protocol: 1,
+            placeholder1: 0,
+            placeholder2: 0,
+        };
+        let mut weight = Weight::zero();
+
+        // Initialize Axons for old_hotkey
+        for netuid in &netuid_is_member {
+            Axons::<Test>::insert(netuid, old_hotkey, axon_info.clone());
+        }
+
+        // Perform the swap
+        SubtensorModule::swap_axons(&old_hotkey, &new_hotkey, &netuid_is_member, &mut weight);
+
+        // Verify the swap
+        for netuid in &netuid_is_member {
+            assert_eq!(Axons::<Test>::get(netuid, new_hotkey).unwrap(), axon_info);
+            assert!(!Axons::<Test>::contains_key(netuid, old_hotkey));
+        }
+    });
+}
+
+#[test]
+fn test_swap_axons_weight_update() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let netuid_is_member = vec![1u16, 2u16];
+        let axon_info = AxonInfo {
+            block: 100,
+            version: 1,
+            ip: 0x1234567890abcdef,
+            port: 8080,
+            ip_type: 4,
+            protocol: 1,
+            placeholder1: 0,
+            placeholder2: 0,
+        };
+        let mut weight = Weight::zero();
+
+        // Initialize Axons for old_hotkey
+        for netuid in &netuid_is_member {
+            Axons::<Test>::insert(netuid, old_hotkey, axon_info.clone());
+        }
+
+        // Perform the swap
+        SubtensorModule::swap_axons(&old_hotkey, &new_hotkey, &netuid_is_member, &mut weight);
+
+        // Verify the weight update
+        let expected_weight = netuid_is_member.len() as u64
+            * <Test as frame_system::Config>::DbWeight::get().reads_writes(1, 2);
+        assert_eq!(weight, expected_weight);
+    });
+}
+
+#[test]
+fn test_swap_keys_success() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let netuid_is_member = vec![1u16, 2u16];
+        let uid = 42u16;
+        let mut weight = Weight::zero();
+
+        // Initialize Keys for old_hotkey
+        for netuid in &netuid_is_member {
+            log::info!("Inserting old_hotkey:{:?} netuid:{:?}", old_hotkey, netuid);
+            Keys::<Test>::insert(*netuid, uid, old_hotkey);
+        }
+
+        // Perform the swap
+        SubtensorModule::swap_keys(&old_hotkey, &new_hotkey, &netuid_is_member, &mut weight);
+
+        // Verify the swap
+        for netuid in &netuid_is_member {
+            log::info!(
+                "neutuid, uid, hotkey: {:?}, {:?}, {:?}",
+                netuid,
+                uid,
+                new_hotkey
+            );
+            assert_eq!(Keys::<Test>::get(netuid, uid), new_hotkey);
+        }
+    });
+}
+
+#[test]
+fn test_swap_keys_weight_update() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let netuid_is_member = vec![1u16, 2u16];
+        let uid = 42u16;
+        let mut weight = Weight::zero();
+
+        // Initialize Keys for old_hotkey
+        for netuid in &netuid_is_member {
+            Keys::<Test>::insert(*netuid, uid, old_hotkey);
+        }
+
+        // Perform the swap
+        SubtensorModule::swap_keys(&old_hotkey, &new_hotkey, &netuid_is_member, &mut weight);
+
+        // Verify the weight update
+        let expected_weight = <Test as frame_system::Config>::DbWeight::get().writes(4);
+        assert_eq!(weight, expected_weight);
+    });
+}
+
+#[test]
+fn test_swap_loaded_emission_success() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let netuid_is_member = vec![1u16, 2u16];
+        let se = 100u64;
+        let ve = 200u64;
+        let mut weight = Weight::zero();
+
+        // Initialize LoadedEmission for old_hotkey
+        for netuid in &netuid_is_member {
+            LoadedEmission::<Test>::mutate(netuid, |emission_exists| {
+                if let Some(emissions) = emission_exists {
+                    emissions.push((old_hotkey, se, ve));
+                } else {
+                    *emission_exists = Some(vec![(old_hotkey, se, ve)]);
+                }
+            });
+        }
+
+        // Perform the swap
+        SubtensorModule::swap_loaded_emission(
+            &old_hotkey,
+            &new_hotkey,
+            &netuid_is_member,
+            &mut weight,
+        );
+
+        // Verify the swap
+        for netuid in &netuid_is_member {
+            let emissions = LoadedEmission::<Test>::get(netuid).unwrap();
+            assert!(emissions.iter().any(|(hk, _, _)| hk == &new_hotkey));
+            assert!(!emissions.iter().any(|(hk, _, _)| hk == &old_hotkey));
+        }
+    });
+}
+
+#[test]
+fn test_swap_loaded_emission_weight_update() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let netuid_is_member = vec![1u16, 2u16];
+        // let uid = 42u64;
+        let se = 100u64;
+        let ve = 200u64;
+        let mut weight = Weight::zero();
+
+        // Initialize LoadedEmission for old_hotkey
+        for netuid in &netuid_is_member {
+            LoadedEmission::<Test>::mutate(netuid, |emission_exists| {
+                if let Some(emissions) = emission_exists {
+                    emissions.push((old_hotkey, se, ve));
+                } else {
+                    *emission_exists = Some(vec![(old_hotkey, se, ve)]);
+                }
+            });
+        }
+
+        // Perform the swap
+        SubtensorModule::swap_loaded_emission(
+            &old_hotkey,
+            &new_hotkey,
+            &netuid_is_member,
+            &mut weight,
+        );
+
+        // Verify the weight update
+        let expected_weight = <Test as frame_system::Config>::DbWeight::get().writes(2);
+        assert_eq!(weight, expected_weight);
+    });
+}
+
+#[test]
+fn test_swap_uids_success() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let netuid_is_member = vec![1u16, 2u16];
+        let uid = 42u16;
+        let mut weight = Weight::zero();
+
+        // Initialize Uids for old_hotkey
+        for netuid in &netuid_is_member {
+            Uids::<Test>::insert(netuid, old_hotkey, uid);
+        }
+
+        // Perform the swap
+        SubtensorModule::swap_uids(&old_hotkey, &new_hotkey, &netuid_is_member, &mut weight);
+
+        // Verify the swap
+        for netuid in &netuid_is_member {
+            assert_eq!(Uids::<Test>::get(netuid, new_hotkey).unwrap(), uid);
+            assert!(!Uids::<Test>::contains_key(netuid, old_hotkey));
+        }
+    });
+}
+
+#[test]
+fn test_swap_uids_weight_update() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let netuid_is_member = vec![1u16, 2u16];
+        let uid = 42u16;
+        let mut weight = Weight::zero();
+
+        // Initialize Uids for old_hotkey
+        for netuid in &netuid_is_member {
+            Uids::<Test>::insert(netuid, old_hotkey, uid);
+        }
+
+        // Perform the swap
+        SubtensorModule::swap_uids(&old_hotkey, &new_hotkey, &netuid_is_member, &mut weight);
+
+        // Verify the weight update
+        let expected_weight = <Test as frame_system::Config>::DbWeight::get().writes(4);
+        assert_eq!(weight, expected_weight);
+    });
+}
+
+#[test]
+fn test_swap_prometheus_success() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let netuid_is_member = vec![1u16, 2u16];
+        let prometheus_info = PrometheusInfo {
+            block: 100,
+            version: 1,
+            ip: 0x1234567890abcdef,
+            port: 8080,
+            ip_type: 4,
+        };
+        let mut weight = Weight::zero();
+
+        // Initialize Prometheus for old_hotkey
+        for netuid in &netuid_is_member {
+            Prometheus::<Test>::insert(netuid, old_hotkey, prometheus_info.clone());
+        }
+
+        // Perform the swap
+        SubtensorModule::swap_prometheus(&old_hotkey, &new_hotkey, &netuid_is_member, &mut weight);
+
+        // Verify the swap
+        for netuid in &netuid_is_member {
+            assert_eq!(
+                Prometheus::<Test>::get(netuid, new_hotkey).unwrap(),
+                prometheus_info
+            );
+            assert!(!Prometheus::<Test>::contains_key(netuid, old_hotkey));
+        }
+    });
+}
+
+#[test]
+fn test_swap_prometheus_weight_update() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let netuid_is_member = vec![1u16, 2u16];
+        let prometheus_info = PrometheusInfo {
+            block: 100,
+            version: 1,
+            ip: 0x1234567890abcdef,
+            port: 8080,
+            ip_type: 4,
+        };
+        let mut weight = Weight::zero();
+
+        // Initialize Prometheus for old_hotkey
+        for netuid in &netuid_is_member {
+            Prometheus::<Test>::insert(netuid, old_hotkey, prometheus_info.clone());
+        }
+
+        // Perform the swap
+        SubtensorModule::swap_prometheus(&old_hotkey, &new_hotkey, &netuid_is_member, &mut weight);
+
+        // Verify the weight update
+        let expected_weight = netuid_is_member.len() as u64
+            * <Test as frame_system::Config>::DbWeight::get().reads_writes(1, 2);
+        assert_eq!(weight, expected_weight);
+    });
+}
+
+#[test]
+fn test_swap_total_hotkey_coldkey_stakes_this_interval_success() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let stake = (1000u64, 42u64); // Example tuple value
+        let mut weight = Weight::zero();
+
+        // Initialize TotalHotkeyColdkeyStakesThisInterval for old_hotkey
+        TotalHotkeyColdkeyStakesThisInterval::<Test>::insert(old_hotkey, coldkey, stake);
+
+        // Perform the swap
+        SubtensorModule::swap_total_hotkey_coldkey_stakes_this_interval(
+            &old_hotkey,
+            &new_hotkey,
+            &mut weight,
+        );
+
+        // Verify the swap
+        assert_eq!(
+            TotalHotkeyColdkeyStakesThisInterval::<Test>::get(new_hotkey, coldkey),
+            stake
+        );
+        assert!(!TotalHotkeyColdkeyStakesThisInterval::<Test>::contains_key(
+            old_hotkey, coldkey
+        ));
+    });
+}
+
+#[test]
+fn test_swap_total_hotkey_coldkey_stakes_this_interval_weight_update() {
+    new_test_ext(1).execute_with(|| {
+        let old_hotkey = U256::from(1);
+        let new_hotkey = U256::from(2);
+        let coldkey = U256::from(3);
+        let stake = (1000u64, 42u64);
+        let mut weight = Weight::zero();
+
+        // Initialize TotalHotkeyColdkeyStakesThisInterval for old_hotkey
+        TotalHotkeyColdkeyStakesThisInterval::<Test>::insert(old_hotkey, coldkey, stake);
+
+        // Perform the swap
+
+        SubtensorModule::swap_total_hotkey_coldkey_stakes_this_interval(
+            &old_hotkey,
+            &new_hotkey,
+            &mut weight,
+        );
+
+        // Verify the weight update
+        let expected_weight = <Test as frame_system::Config>::DbWeight::get().writes(2);
+        assert_eq!(weight, expected_weight);
+    });
+}
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index bb7059893..9a43fdf93 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -868,6 +868,7 @@ parameter_types! {
     pub const SubtensorInitialNetworkLockReductionInterval: u64 = 14 * 7200;
     pub const SubtensorInitialNetworkRateLimit: u64 = 7200;
     pub const SubtensorInitialTargetStakesPerInterval: u16 = 1;
+    pub const SubtensorInitialHotkeySwapCost: u64 = 1_000_000_000;
     pub const InitialAlphaHigh: u16 = 58982; // Represents 0.9 as per the production default
     pub const InitialAlphaLow: u16 = 45875; // Represents 0.7 as per the production default
     pub const InitialLiquidAlphaOn: bool = false; // Default value for LiquidAlphaOn
@@ -922,6 +923,7 @@ impl pallet_subtensor::Config for Runtime {
     type InitialSubnetLimit = SubtensorInitialSubnetLimit;
     type InitialNetworkRateLimit = SubtensorInitialNetworkRateLimit;
     type InitialTargetStakesPerInterval = SubtensorInitialTargetStakesPerInterval;
+    type HotkeySwapCost = SubtensorInitialHotkeySwapCost;
     type AlphaHigh = InitialAlphaHigh;
     type AlphaLow = InitialAlphaLow;
     type LiquidAlphaOn = InitialLiquidAlphaOn;