Merge pull request opentensor#1178 from opentensor/feat/transfer-stake

Transfer Coldkey Stake

Author: sam0x17

pallets/subtensor/src/macros/dispatches.rs

@@ -1606,5 +1606,49 @@ mod dispatches {
                 alpha_amount,
             )
         }
+
+        /// Transfers a specified amount of stake from one coldkey to another, optionally across subnets,
+        /// while keeping the same hotkey.
+        ///
+        /// # Arguments
+        /// * `origin` - The origin of the transaction, which must be signed by the `origin_coldkey`.
+        /// * `destination_coldkey` - The coldkey to which the stake is transferred.
+        /// * `hotkey` - The hotkey associated with the stake.
+        /// * `origin_netuid` - The network/subnet ID to move stake from.
+        /// * `destination_netuid` - The network/subnet ID to move stake to (for cross-subnet transfer).
+        /// * `alpha_amount` - The amount of stake to transfer.
+        ///
+        /// # Weight
+        /// Uses a fixed weight of 3_000_000 (plus any DB write overhead).
+        ///
+        /// # Errors
+        /// Returns an error if:
+        /// * The origin is not signed by the correct coldkey.
+        /// * Either subnet does not exist.
+        /// * The hotkey does not exist.
+        /// * There is insufficient stake on `(origin_coldkey, hotkey, origin_netuid)`.
+        /// * The transfer amount is below the minimum stake requirement.
+        ///
+        /// # Events
+        /// May emit a `StakeTransferred` event on success.
+        #[pallet::call_index(86)]
+        #[pallet::weight((Weight::from_parts(3_000_000, 0).saturating_add(T::DbWeight::get().writes(1)), DispatchClass::Operational, Pays::No))]
+        pub fn transfer_stake(
+            origin: T::RuntimeOrigin,
+            destination_coldkey: T::AccountId,
+            hotkey: T::AccountId,
+            origin_netuid: u16,
+            destination_netuid: u16,
+            alpha_amount: u64,
+        ) -> DispatchResult {
+            Self::do_transfer_stake(
+                origin,
+                destination_coldkey,
+                hotkey,
+                origin_netuid,
+                destination_netuid,
+                alpha_amount,
+            )
+        }
     }
 }

pallets/subtensor/src/macros/events.rs

@@ -252,5 +252,10 @@ mod events {
         ///
         /// - **error**: The dispatch error emitted by the failed item.
         BatchWeightItemFailed(sp_runtime::DispatchError),
+
+        /// Stake has been transferred from one coldkey to another on the same subnet.
+        /// Parameters:
+        /// (origin_coldkey, destination_coldkey, hotkey, origin_netuid, destination_netuid, amount)
+        StakeTransferred(T::AccountId, T::AccountId, T::AccountId, u16, u16, u64),
     }
 }

pallets/subtensor/src/staking/move_stake.rs

@@ -110,4 +110,111 @@ impl<T: Config> Pallet<T> {
         // -- 10. Ok and return.
         Ok(())
     }
+
+    /// Transfers stake from one coldkey to another, optionally moving from one subnet to another,
+    /// while keeping the same hotkey.
+    ///
+    /// # Arguments
+    /// * `origin` - The origin of the transaction, which must be signed by the `origin_coldkey`.
+    /// * `destination_coldkey` - The account ID of the coldkey to which the stake is being transferred.
+    /// * `hotkey` - The account ID of the hotkey associated with this stake.
+    /// * `origin_netuid` - The network ID (subnet) from which the stake is being transferred.
+    /// * `destination_netuid` - The network ID (subnet) to which the stake is being transferred.
+    /// * `alpha_amount` - The amount of stake to transfer.
+    ///
+    /// # Returns
+    /// * `DispatchResult` - Indicates success or failure.
+    ///
+    /// # Errors
+    /// This function will return an error if:
+    /// * The transaction is not signed by the `origin_coldkey`.
+    /// * The subnet (`origin_netuid` or `destination_netuid`) does not exist.
+    /// * The `hotkey` does not exist.
+    /// * The `(origin_coldkey, hotkey, origin_netuid)` does not have enough stake for `alpha_amount`.
+    /// * The amount to be transferred is below the minimum stake requirement.
+    /// * There is a failure in staking or unstaking logic.
+    ///
+    /// # Events
+    /// Emits a `StakeTransferred` event upon successful completion of the transfer.
+    pub fn do_transfer_stake(
+        origin: T::RuntimeOrigin,
+        destination_coldkey: T::AccountId,
+        hotkey: T::AccountId,
+        origin_netuid: u16,
+        destination_netuid: u16,
+        alpha_amount: u64,
+    ) -> dispatch::DispatchResult {
+        // 1. Ensure the extrinsic is signed by the origin_coldkey.
+        let coldkey = ensure_signed(origin)?;
+
+        // 2. Ensure both subnets exist.
+        ensure!(
+            Self::if_subnet_exist(origin_netuid),
+            Error::<T>::SubnetNotExists
+        );
+        ensure!(
+            Self::if_subnet_exist(destination_netuid),
+            Error::<T>::SubnetNotExists
+        );
+
+        // 3. Check that the hotkey exists.
+        ensure!(
+            Self::hotkey_account_exists(&hotkey),
+            Error::<T>::HotKeyAccountNotExists
+        );
+
+        // 4. Check that the signed coldkey actually owns the given hotkey.
+        ensure!(
+            Self::coldkey_owns_hotkey(&coldkey, &hotkey),
+            Error::<T>::NonAssociatedColdKey
+        );
+
+        // 5. Get current stake.
+        let origin_alpha =
+            Self::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, origin_netuid);
+        ensure!(
+            alpha_amount <= origin_alpha,
+            Error::<T>::NotEnoughStakeToWithdraw
+        );
+
+        // 6. Unstake from the origin coldkey; this returns an amount of TAO.
+        let origin_tao = Self::unstake_from_subnet(&hotkey, &coldkey, origin_netuid, alpha_amount);
+
+        // 7. Ensure the returned TAO meets a minimum stake requirement (if required).
+        ensure!(
+            origin_tao >= DefaultMinStake::<T>::get(),
+            Error::<T>::AmountTooLow
+        );
+
+        // 8. Stake the TAO into `(destination_coldkey, hotkey)` on the destination subnet.
+        //    Create the account if it does not exist.
+        Self::stake_into_subnet(
+            &hotkey,
+            &destination_coldkey,
+            destination_netuid,
+            origin_tao,
+        );
+
+        // 9. Emit an event for logging/monitoring.
+        log::info!(
+            "StakeTransferred(origin_coldkey: {:?}, destination_coldkey: {:?}, hotkey: {:?}, origin_netuid: {:?}, destination_netuid: {:?}, amount: {:?})",
+            coldkey,
+            destination_coldkey,
+            hotkey,
+            origin_netuid,
+            destination_netuid,
+            origin_tao
+        );
+        Self::deposit_event(Event::StakeTransferred(
+            coldkey,
+            destination_coldkey,
+            hotkey,
+            origin_netuid,
+            destination_netuid,
+            origin_tao,
+        ));
+
+        // 10. Return success.
+        Ok(())
+    }
 }