Ban to_num, organize safe math into a crate

Author: gztensor

Cargo.lock

@@ -41,6 +41,7 @@ pallet-utility = { workspace = true }
 ndarray = { workspace = true }
 hex = { workspace = true }
 share-pool = { default-features = false, path = "../../primitives/share-pool" }
+safe-math = { default-features = false, path = "../../primitives/safe-math" }
 approx = { workspace = true }
 
 pallet-collective = { version = "4.0.0-dev", default-features = false, path = "../collective" }

pallets/subtensor/Cargo.toml

@@ -1,6 +1,6 @@
 use super::*;
-use crate::epoch::math::*;
 use frame_support::traits::Get;
+use safe_math::*;
 use substrate_fixed::{transcendental::log2, types::I96F32};
 
 impl<T: Config> Pallet<T> {
@@ -81,9 +81,9 @@ impl<T: Config> Pallet<T> {
 
         // Return result.
         (
-            tao_in_emission.to_num::<u64>(),
-            alpha_in_emission.to_num::<u64>(),
-            alpha_out_emission.to_num::<u64>(),
+            tao_in_emission.saturating_to_num::<u64>(),
+            alpha_in_emission.saturating_to_num::<u64>(),
+            alpha_out_emission.saturating_to_num::<u64>(),
         )
     }
 
@@ -134,7 +134,7 @@ impl<T: Config> Pallet<T> {
         let floored_residual: I96F32 = residual.floor();
         // Calculate the final emission rate using the floored residual.
         // Convert floored_residual to an integer
-        let floored_residual_int: u64 = floored_residual.to_num::<u64>();
+        let floored_residual_int: u64 = floored_residual.saturating_to_num::<u64>();
         // Multiply 2.0 by itself floored_residual times to calculate the power of 2.
         let mut multiplier: I96F32 = I96F32::from_num(1.0);
         for _ in 0..floored_residual_int {
@@ -145,7 +145,7 @@ impl<T: Config> Pallet<T> {
         let block_emission: I96F32 = block_emission_percentage
             .saturating_mul(I96F32::from_num(DefaultBlockEmission::<T>::get()));
         // Convert to u64
-        let block_emission_u64: u64 = block_emission.to_num::<u64>();
+        let block_emission_u64: u64 = block_emission.saturating_to_num::<u64>();
         if BlockEmission::<T>::get() != block_emission_u64 {
             BlockEmission::<T>::put(block_emission_u64);
         }

pallets/subtensor/src/coinbase/block_emission.rs

@@ -1,6 +1,6 @@
 use super::*;
-use crate::epoch::math::*;
 use frame_support::storage::IterableStorageMap;
+use safe_math::*;
 use substrate_fixed::types::{I110F18, I96F32};
 
 impl<T: Config + pallet_drand::Config> Pallet<T> {
@@ -220,7 +220,7 @@ impl<T: Config + pallet_drand::Config> Pallet<T> {
         } else if next_value <= I110F18::from_num(Self::get_min_difficulty(netuid)) {
             return Self::get_min_difficulty(netuid);
         } else {
-            return next_value.to_num::<u64>();
+            return next_value.saturating_to_num::<u64>();
         }
     }
 
@@ -254,7 +254,7 @@ impl<T: Config + pallet_drand::Config> Pallet<T> {
         } else if next_value <= I110F18::from_num(Self::get_min_burn_as_u64(netuid)) {
             return Self::get_min_burn_as_u64(netuid);
         } else {
-            return next_value.to_num::<u64>();
+            return next_value.saturating_to_num::<u64>();
         }
     }
 }

pallets/subtensor/src/coinbase/block_step.rs

@@ -16,10 +16,10 @@
 // DEALINGS IN THE SOFTWARE.
 
 use super::*;
-use crate::epoch::math::*;
 use frame_support::dispatch::Pays;
 use frame_support::storage::IterableStorageDoubleMap;
 use frame_support::weights::Weight;
+use safe_math::*;
 use sp_core::Get;
 use sp_std::vec;
 use substrate_fixed::types::I64F64;

pallets/subtensor/src/coinbase/root.rs

@@ -1,6 +1,6 @@
 use super::*;
-use crate::epoch::math::*;
 use alloc::collections::BTreeMap;
+use safe_math::*;
 use substrate_fixed::types::I96F32;
 use tle::stream_ciphers::AESGCMStreamCipherProvider;
 use tle::tlock::tld;
@@ -118,7 +118,7 @@ impl<T: Config> Pallet<T> {
             let tao_in: u64 = mech_emission
                 .checked_mul(subnet_proportion)
                 .unwrap_or(I96F32::from_num(0))
-                .to_num::<u64>();
+                .saturating_to_num::<u64>();
             log::debug!(
                 "Subnet TAO emission (E_s) for netuid {:?}: {:?}",
                 netuid,
@@ -201,7 +201,7 @@ impl<T: Config> Pallet<T> {
             // Calculate the owner cut.
             let owner_cut: u64 = I96F32::from_num(alpha_out_emission)
                 .saturating_mul(Self::get_float_subnet_owner_cut())
-                .to_num::<u64>();
+                .saturating_to_num::<u64>();
             log::debug!("Owner cut for netuid {:?}: {:?}", netuid, owner_cut);
             // Store the owner cut for this subnet.
             *owner_cuts.entry(*netuid).or_insert(0) = owner_cut;
@@ -225,20 +225,25 @@ impl<T: Config> Pallet<T> {
             let pending_alpha_emission: I96F32 =
                 I96F32::from_num(remaining_emission).saturating_sub(root_emission_in_alpha);
             // Sell root emission through the pool.
-            let root_emission_in_tao: u64 =
-                Self::swap_alpha_for_tao(*netuid, root_emission_in_alpha.to_num::<u64>());
-            SubnetAlphaEmissionSell::<T>::insert(*netuid, root_emission_in_alpha.to_num::<u64>());
+            let root_emission_in_tao: u64 = Self::swap_alpha_for_tao(
+                *netuid,
+                root_emission_in_alpha.saturating_to_num::<u64>(),
+            );
+            SubnetAlphaEmissionSell::<T>::insert(
+                *netuid,
+                root_emission_in_alpha.saturating_to_num::<u64>(),
+            );
             // Accumulate root divs for subnet.
             PendingRootDivs::<T>::mutate(*netuid, |total| {
                 *total = total.saturating_add(root_emission_in_tao);
             });
             // Accumulate alpha that was swapped for the pending root divs.
             PendingAlphaSwapped::<T>::mutate(*netuid, |total| {
-                *total = total.saturating_add(root_emission_in_alpha.to_num::<u64>());
+                *total = total.saturating_add(root_emission_in_alpha.saturating_to_num::<u64>());
             });
             // Accumulate alpha emission in pending.
             PendingEmission::<T>::mutate(*netuid, |total| {
-                *total = total.saturating_add(pending_alpha_emission.to_num::<u64>());
+                *total = total.saturating_add(pending_alpha_emission.saturating_to_num::<u64>());
             });
             // Accumulate the owner cut in pending.
             PendingOwnerCut::<T>::mutate(*netuid, |total| {
@@ -413,14 +418,14 @@ impl<T: Config> Pallet<T> {
                 // Store the root-alpha divs under hotkey_j
                 root_alpha_divs
                     .entry(hotkey_j.clone())
-                    .and_modify(|e| *e = e.saturating_add(root_divs.to_num::<u64>()))
-                    .or_insert(root_divs.to_num::<u64>());
+                    .and_modify(|e| *e = e.saturating_add(root_divs.saturating_to_num::<u64>()))
+                    .or_insert(root_divs.saturating_to_num::<u64>());
                 total_root_alpha_divs =
-                    total_root_alpha_divs.saturating_add(root_divs.to_num::<u64>());
+                    total_root_alpha_divs.saturating_add(root_divs.saturating_to_num::<u64>());
                 log::debug!(
                     "Stored root alpha dividends for hotkey {:?}: {:?}",
                     hotkey_j,
-                    root_divs.to_num::<u64>()
+                    root_divs.saturating_to_num::<u64>()
                 );
             }
         }
@@ -478,26 +483,26 @@ impl<T: Config> Pallet<T> {
                     hotkey_j,
                     &Owner::<T>::get(hotkey_j.clone()),
                     netuid,
-                    validator_take.to_num::<u64>(),
+                    validator_take.saturating_to_num::<u64>(),
                 );
                 log::debug!(
                     "Distributed validator take for hotkey {:?} on netuid {:?}: {:?}",
                     hotkey_j,
                     netuid,
-                    validator_take.to_num::<u64>()
+                    validator_take.saturating_to_num::<u64>()
                 );
 
                 // Distribute the alpha divs to the hotkey.
                 Self::increase_stake_for_hotkey_on_subnet(
                     hotkey_j,
                     netuid,
-                    rem_divs_j.to_num::<u64>(),
+                    rem_divs_j.saturating_to_num::<u64>(),
                 );
                 log::debug!(
                     "Distributed alpha dividends for hotkey {:?} on netuid {:?}: {:?}",
                     hotkey_j,
                     netuid,
-                    rem_divs_j.to_num::<u64>()
+                    rem_divs_j.saturating_to_num::<u64>()
                 );
 
                 // Record dividends for this hotkey on this subnet.
@@ -522,7 +527,7 @@ impl<T: Config> Pallet<T> {
                 .unwrap_or(I96F32::from_num(0));
             let root_divs_to_pay: u64 = proportion
                 .saturating_mul(I96F32::from_num(pending_root_divs))
-                .to_num::<u64>();
+                .saturating_to_num::<u64>();
             log::debug!(
                 "Proportion for hotkey {:?}: {:?}, root_divs_to_pay: {:?}",
                 hotkey_j,
@@ -581,7 +586,7 @@ impl<T: Config> Pallet<T> {
         let combined_contribution: I96F32 = alpha_contribution.saturating_add(root_contribution);
 
         // Return the combined contribution as a u64
-        combined_contribution.to_num::<u64>()
+        combined_contribution.saturating_to_num::<u64>()
     }
 
     /// Returns a list of tuples for each parent associated with this hotkey including self
@@ -695,7 +700,7 @@ impl<T: Config> Pallet<T> {
                 .checked_div(total_contribution)
                 .unwrap_or(I96F32::from_num(0));
             let parent_emission: u64 =
-                (remaining_emission.saturating_mul(emission_factor)).to_num::<u64>();
+                (remaining_emission.saturating_mul(emission_factor)).saturating_to_num::<u64>();
 
             // Add the parent's emission to the distribution list
             dividend_tuples.push((parent, parent_emission));
@@ -707,7 +712,7 @@ impl<T: Config> Pallet<T> {
         // This includes the take left from the parents and the self contribution.
         let child_emission = remaining_emission
             .saturating_add(child_emission_take)
-            .to_num::<u64>()
+            .saturating_to_num::<u64>()
             .saturating_sub(to_parents);
 
         // Add the hotkey's own emission to the distribution list

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -3,12 +3,13 @@
 use crate::alloc::borrow::ToOwned;
 #[allow(unused)]
 use num_traits::float::Float;
+use safe_math::*;
 use sp_runtime::traits::{CheckedAdd, Saturating};
 use sp_std::cmp::Ordering;
 
 use sp_std::vec;
 use substrate_fixed::transcendental::{exp, ln};
-use substrate_fixed::types::{I110F18, I32F32, I64F64, I96F32, U64F64};
+use substrate_fixed::types::{I32F32, I64F64};
 
 // TODO: figure out what cfg gate this needs to not be a warning in rustc
 #[allow(unused)]
@@ -21,17 +22,17 @@ pub fn fixed(val: f32) -> I32F32 {
 
 #[allow(dead_code)]
 pub fn fixed_to_u16(x: I32F32) -> u16 {
-    x.to_num::<u16>()
+    x.saturating_to_num::<u16>()
 }
 
 #[allow(dead_code)]
 pub fn fixed_to_u64(x: I32F32) -> u64 {
-    x.to_num::<u64>()
+    x.saturating_to_num::<u64>()
 }
 
 #[allow(dead_code)]
 pub fn fixed64_to_u64(x: I64F64) -> u64 {
-    x.to_num::<u64>()
+    x.saturating_to_num::<u64>()
 }
 
 #[allow(dead_code)]
@@ -100,7 +101,7 @@ pub fn vec_max_upscale_to_u16(vec: &[I32F32]) -> Vec<u16> {
             if *val == I32F32::from_num(0) {
                 return vec
                     .iter()
-                    .map(|e: &I32F32| e.saturating_mul(u16_max).to_num::<u16>())
+                    .map(|e: &I32F32| e.saturating_mul(u16_max).saturating_to_num::<u16>())
                     .collect();
             }
             if *val > threshold {
@@ -109,7 +110,7 @@ pub fn vec_max_upscale_to_u16(vec: &[I32F32]) -> Vec<u16> {
                     .map(|e: &I32F32| {
                         e.saturating_mul(u16_max.safe_div(*val))
                             .round()
-                            .to_num::<u16>()
+                            .saturating_to_num::<u16>()
                     })
                     .collect();
             }
@@ -118,14 +119,18 @@ pub fn vec_max_upscale_to_u16(vec: &[I32F32]) -> Vec<u16> {
                     e.saturating_mul(u16_max)
                         .safe_div(*val)
                         .round()
-                        .to_num::<u16>()
+                        .saturating_to_num::<u16>()
                 })
                 .collect()
         }
         None => {
             let sum: I32F32 = vec.iter().sum();
             vec.iter()
-                .map(|e: &I32F32| e.saturating_mul(u16_max).safe_div(sum).to_num::<u16>())
+                .map(|e: &I32F32| {
+                    e.saturating_mul(u16_max)
+                        .safe_div(sum)
+                        .saturating_to_num::<u16>()
+                })
                 .collect()
         }
     }
@@ -1406,48 +1411,3 @@ pub fn safe_ln(value: I32F32) -> I32F32 {
 pub fn safe_exp(value: I32F32) -> I32F32 {
     exp(value).unwrap_or(I32F32::from_num(0.0))
 }
-
-/// Safe division trait
-pub trait SafeDiv {
-    /// Safe division that returns supplied default value for division by zero
-    fn safe_div_or(self, rhs: Self, def: Self) -> Self;
-    /// Safe division that returns default value for division by zero
-    fn safe_div(self, rhs: Self) -> Self;
-}
-
-/// Implementation of safe division trait for primitive types
-macro_rules! impl_safe_div_for_primitive {
-    ($($t:ty),*) => {
-        $(
-            impl SafeDiv for $t {
-                fn safe_div_or(self, rhs: Self, def: Self) -> Self {
-                    self.checked_div(rhs).unwrap_or(def)
-                }
-
-                fn safe_div(self, rhs: Self) -> Self {
-                    self.checked_div(rhs).unwrap_or_default()
-                }
-            }
-        )*
-    };
-}
-impl_safe_div_for_primitive!(u8, u16, u32, u64, i8, i16, i32, i64, usize);
-
-/// Implementation of safe division trait for substrate fixed types
-macro_rules! impl_safe_div_for_fixed {
-    ($($t:ty),*) => {
-        $(
-            impl SafeDiv for $t {
-                fn safe_div_or(self, rhs: Self, def: Self) -> Self {
-                    self.checked_div(rhs).unwrap_or(def)
-                }
-
-                fn safe_div(self, rhs: Self) -> Self {
-                    self.checked_div(rhs).unwrap_or_default()
-                }
-            }
-        )*
-    };
-}
-
-impl_safe_div_for_fixed!(I96F32, I32F32, I64F64, I110F18, U64F64);