Return actual recycled/burned alpha amount from pallet

Author: LandynDev

chain-extensions/src/lib.rs

@@ -536,16 +536,16 @@ where
 
                 let caller = env.caller();
 
-                let call_result = pallet_subtensor::Pallet::<T>::recycle_alpha(
+                let call_result = pallet_subtensor::Pallet::<T>::do_recycle_alpha(
                     RawOrigin::Signed(caller).into(),
                     hotkey,
                     amount,
                     netuid,
                 );
 
                 match call_result {
-                    Ok(_) => {
-                        env.write_output(&amount.encode())
+                    Ok(real_amount) => {
+                        env.write_output(&real_amount.encode())
                             .map_err(|_| DispatchError::Other("Failed to write output"))?;
                         Ok(RetVal::Converging(Output::Success as u32))
                     }
@@ -567,16 +567,16 @@ where
 
                 let caller = env.caller();
 
-                let call_result = pallet_subtensor::Pallet::<T>::burn_alpha(
+                let call_result = pallet_subtensor::Pallet::<T>::do_burn_alpha(
                     RawOrigin::Signed(caller).into(),
                     hotkey,
                     amount,
                     netuid,
                 );
 
                 match call_result {
-                    Ok(_) => {
-                        env.write_output(&amount.encode())
+                    Ok(real_amount) => {
+                        env.write_output(&real_amount.encode())
                             .map_err(|_| DispatchError::Other("Failed to write output"))?;
                         Ok(RetVal::Converging(Output::Success as u32))
                     }
@@ -609,13 +609,13 @@ where
                         Err(e) => return TransactionOutcome::Rollback(Err(e)),
                     };
 
-                    match pallet_subtensor::Pallet::<T>::recycle_alpha(
+                    match pallet_subtensor::Pallet::<T>::do_recycle_alpha(
                         RawOrigin::Signed(caller).into(),
                         hotkey,
                         alpha,
                         netuid,
                     ) {
-                        Ok(_) => TransactionOutcome::Commit(Ok(alpha)),
+                        Ok(real_alpha) => TransactionOutcome::Commit(Ok(real_alpha)),
                         Err(e) => TransactionOutcome::Rollback(Err(e)),
                     }
                 });
@@ -655,13 +655,13 @@ where
                         Err(e) => return TransactionOutcome::Rollback(Err(e)),
                     };
 
-                    match pallet_subtensor::Pallet::<T>::burn_alpha(
+                    match pallet_subtensor::Pallet::<T>::do_burn_alpha(
                         RawOrigin::Signed(caller).into(),
                         hotkey,
                         alpha,
                         netuid,
                     ) {
-                        Ok(_) => TransactionOutcome::Commit(Ok(alpha)),
+                        Ok(real_alpha) => TransactionOutcome::Commit(Ok(real_alpha)),
                         Err(e) => TransactionOutcome::Rollback(Err(e)),
                     }
                 });

chain-extensions/src/tests.rs

@@ -1141,8 +1141,8 @@ fn recycle_alpha_clamps_to_available_when_amount_exceeds_stake() {
 
         let returned_amount = AlphaBalance::decode(&mut env.output()).unwrap();
         assert_eq!(
-            returned_amount, huge_amount,
-            "should return requested amount"
+            returned_amount, alpha_before,
+            "should return actual clamped amount, not requested amount"
         );
 
         let alpha_after =
@@ -1242,8 +1242,8 @@ fn burn_alpha_clamps_to_available_when_amount_exceeds_stake() {
 
         let returned_amount = AlphaBalance::decode(&mut env.output()).unwrap();
         assert_eq!(
-            returned_amount, huge_amount,
-            "should return requested amount"
+            returned_amount, alpha_before,
+            "should return actual clamped amount, not requested amount"
         );
 
         let alpha_after =

pallets/subtensor/src/macros/dispatches.rs

@@ -1857,7 +1857,7 @@ mod dispatches {
             amount: AlphaBalance,
             netuid: NetUid,
         ) -> DispatchResult {
-            Self::do_recycle_alpha(origin, hotkey, amount, netuid)
+            Self::do_recycle_alpha(origin, hotkey, amount, netuid).map(|_| ())
         }
 
         /// Burns alpha from a cold/hot key pair without reducing `AlphaOut`
@@ -1878,7 +1878,7 @@ mod dispatches {
             amount: AlphaBalance,
             netuid: NetUid,
         ) -> DispatchResult {
-            Self::do_burn_alpha(origin, hotkey, amount, netuid)
+            Self::do_burn_alpha(origin, hotkey, amount, netuid).map(|_| ())
         }
 
         /// Sets the pending childkey cooldown (in blocks). Root only.

pallets/subtensor/src/staking/recycle_alpha.rs

@@ -14,13 +14,13 @@ impl<T: Config> Pallet<T> {
     ///
     /// # Returns
     ///
-    /// * `DispatchResult` - Success or error
-    pub(crate) fn do_recycle_alpha(
+    /// * `Result<AlphaBalance, DispatchError>` - The actual amount recycled, or error
+    pub fn do_recycle_alpha(
         origin: OriginFor<T>,
         hotkey: T::AccountId,
         amount: AlphaBalance,
         netuid: NetUid,
-    ) -> DispatchResult {
+    ) -> Result<AlphaBalance, DispatchError> {
         let coldkey: T::AccountId = ensure_signed(origin)?;
 
         ensure!(Self::if_subnet_exist(netuid), Error::<T>::SubnetNotExists);
@@ -58,7 +58,7 @@ impl<T: Config> Pallet<T> {
 
         Self::deposit_event(Event::AlphaRecycled(coldkey, hotkey, amount, netuid));
 
-        Ok(())
+        Ok(amount)
     }
 
     /// Burns alpha from a cold/hot key pair without reducing AlphaOut
@@ -72,13 +72,13 @@ impl<T: Config> Pallet<T> {
     ///
     /// # Returns
     ///
-    /// * `DispatchResult` - Success or error
-    pub(crate) fn do_burn_alpha(
+    /// * `Result<AlphaBalance, DispatchError>` - The actual amount burned, or error
+    pub fn do_burn_alpha(
         origin: OriginFor<T>,
         hotkey: T::AccountId,
         amount: AlphaBalance,
         netuid: NetUid,
-    ) -> DispatchResult {
+    ) -> Result<AlphaBalance, DispatchError> {
         let coldkey = ensure_signed(origin)?;
 
         ensure!(Self::if_subnet_exist(netuid), Error::<T>::SubnetNotExists);
@@ -116,7 +116,7 @@ impl<T: Config> Pallet<T> {
         // Deposit event
         Self::deposit_event(Event::AlphaBurned(coldkey, hotkey, amount, netuid));
 
-        Ok(())
+        Ok(amount)
     }
     pub(crate) fn do_add_stake_burn(
         origin: OriginFor<T>,