Remove swap pallet error shadowing in max_amount staking calculators

Author: ales-otf

pallets/subtensor/src/staking/add_stake.rs

@@ -180,28 +180,30 @@ impl<T: Config> Pallet<T> {
     }
 
     // Returns the maximum amount of RAO that can be executed with price limit
-    pub fn get_max_amount_add(netuid: NetUid, limit_price: TaoCurrency) -> Result<u64, Error<T>> {
+    pub fn get_max_amount_add(
+        netuid: NetUid,
+        limit_price: TaoCurrency,
+    ) -> Result<u64, DispatchError> {
         // Corner case: root and stao
         // There's no slippage for root or stable subnets, so if limit price is 1e9 rao or
         // higher, then max_amount equals u64::MAX, otherwise it is 0.
         if netuid.is_root() || SubnetMechanism::<T>::get(netuid) == 0 {
             if limit_price >= 1_000_000_000.into() {
                 return Ok(u64::MAX);
             } else {
-                return Err(Error::ZeroMaxStakeAmount);
+                return Err(Error::<T>::ZeroMaxStakeAmount.into());
             }
         }
 
         // Use reverting swap to estimate max limit amount
         let order = GetAlphaForTao::<T>::with_amount(u64::MAX);
         let result = T::SwapInterface::swap(netuid.into(), order, limit_price, false, true)
-            .map(|r| r.amount_paid_in.saturating_add(r.fee_paid))
-            .map_err(|_| Error::ZeroMaxStakeAmount)?;
+            .map(|r| r.amount_paid_in.saturating_add(r.fee_paid))?;
 
         if !result.is_zero() {
             Ok(result.into())
         } else {
-            Err(Error::ZeroMaxStakeAmount)
+            Err(Error::<T>::ZeroMaxStakeAmount.into())
         }
     }
 }

pallets/subtensor/src/staking/move_stake.rs

@@ -424,8 +424,8 @@ impl<T: Config> Pallet<T> {
         origin_netuid: NetUid,
         destination_netuid: NetUid,
         limit_price: TaoCurrency,
-    ) -> Result<AlphaCurrency, Error<T>> {
-        let tao: U64F64 = U64F64::saturating_from_num(1_000_000_000);
+    ) -> Result<AlphaCurrency, DispatchError> {
+        let tao = U64F64::saturating_from_num(1_000_000_000);
 
         // Corner case: both subnet IDs are root or stao
         // There's no slippage for root or stable subnets, so slippage is always 0.
@@ -434,7 +434,7 @@ impl<T: Config> Pallet<T> {
             && (destination_netuid.is_root() || SubnetMechanism::<T>::get(destination_netuid) == 0)
         {
             if limit_price > tao.saturating_to_num::<u64>().into() {
-                return Err(Error::ZeroMaxStakeAmount);
+                return Err(Error::<T>::ZeroMaxStakeAmount.into());
             } else {
                 return Ok(AlphaCurrency::MAX);
             }
@@ -476,7 +476,7 @@ impl<T: Config> Pallet<T> {
         let subnet_tao_2 = SubnetTAO::<T>::get(destination_netuid)
             .saturating_add(SubnetTaoProvided::<T>::get(destination_netuid));
         if subnet_tao_1.is_zero() || subnet_tao_2.is_zero() {
-            return Err(Error::ZeroMaxStakeAmount);
+            return Err(Error::<T>::ZeroMaxStakeAmount.into());
         }
         let subnet_tao_1_float: U64F64 = U64F64::saturating_from_num(subnet_tao_1);
         let subnet_tao_2_float: U64F64 = U64F64::saturating_from_num(subnet_tao_2);
@@ -487,7 +487,7 @@ impl<T: Config> Pallet<T> {
         let alpha_in_2 = SubnetAlphaIn::<T>::get(destination_netuid)
             .saturating_add(SubnetAlphaInProvided::<T>::get(destination_netuid));
         if alpha_in_1.is_zero() || alpha_in_2.is_zero() {
-            return Err(Error::ZeroMaxStakeAmount);
+            return Err(Error::<T>::ZeroMaxStakeAmount.into());
         }
         let alpha_in_1_float: U64F64 = U64F64::saturating_from_num(alpha_in_1);
         let alpha_in_2_float: U64F64 = U64F64::saturating_from_num(alpha_in_2);
@@ -503,7 +503,7 @@ impl<T: Config> Pallet<T> {
             T::SwapInterface::current_alpha_price(destination_netuid.into()),
         );
         if limit_price_float > current_price {
-            return Err(Error::ZeroMaxStakeAmount);
+            return Err(Error::<T>::ZeroMaxStakeAmount.into());
         }
 
         // Corner case: limit_price is zero
@@ -529,7 +529,7 @@ impl<T: Config> Pallet<T> {
         if final_result != 0 {
             Ok(final_result.into())
         } else {
-            Err(Error::ZeroMaxStakeAmount)
+            Err(Error::<T>::ZeroMaxStakeAmount.into())
         }
     }
 }

pallets/subtensor/src/staking/remove_stake.rs

@@ -391,28 +391,27 @@ impl<T: Config> Pallet<T> {
     pub fn get_max_amount_remove(
         netuid: NetUid,
         limit_price: TaoCurrency,
-    ) -> Result<AlphaCurrency, Error<T>> {
+    ) -> Result<AlphaCurrency, DispatchError> {
         // Corner case: root and stao
         // There's no slippage for root or stable subnets, so if limit price is 1e9 rao or
         // lower, then max_amount equals u64::MAX, otherwise it is 0.
         if netuid.is_root() || SubnetMechanism::<T>::get(netuid) == 0 {
             if limit_price <= 1_000_000_000.into() {
                 return Ok(AlphaCurrency::MAX);
             } else {
-                return Err(Error::ZeroMaxStakeAmount);
+                return Err(Error::<T>::ZeroMaxStakeAmount.into());
             }
         }
 
         // Use reverting swap to estimate max limit amount
         let order = GetTaoForAlpha::<T>::with_amount(u64::MAX);
         let result = T::SwapInterface::swap(netuid.into(), order, limit_price.into(), false, true)
-            .map(|r| r.amount_paid_in.saturating_add(r.fee_paid))
-            .map_err(|_| Error::ZeroMaxStakeAmount)?;
+            .map(|r| r.amount_paid_in.saturating_add(r.fee_paid))?;
 
         if !result.is_zero() {
             Ok(result)
         } else {
-            Err(Error::ZeroMaxStakeAmount)
+            Err(Error::<T>::ZeroMaxStakeAmount.into())
         }
     }