Merge pull request #1485 from opentensor/fix/get-rid-of-i96

Do not use saturating_sub for signed types

Author: sam0x17

pallets/subtensor/src/coinbase/block_emission.rs

@@ -1,7 +1,10 @@
 use super::*;
 use frame_support::traits::Get;
 use safe_math::*;
-use substrate_fixed::{transcendental::log2, types::I96F32};
+use substrate_fixed::{
+    transcendental::log2,
+    types::{I96F32, U96F32},
+};
 
 impl<T: Config> Pallet<T> {
     /// Calculates the dynamic TAO emission for a given subnet.
@@ -31,15 +34,15 @@ impl<T: Config> Pallet<T> {
         alpha_block_emission: u64,
     ) -> (u64, u64, u64) {
         // Init terms.
-        let mut tao_in_emission: I96F32 = I96F32::saturating_from_num(tao_emission);
-        let float_alpha_block_emission: I96F32 = I96F32::saturating_from_num(alpha_block_emission);
+        let mut tao_in_emission: U96F32 = U96F32::saturating_from_num(tao_emission);
+        let float_alpha_block_emission: U96F32 = U96F32::saturating_from_num(alpha_block_emission);
 
         // Get alpha price for subnet.
-        let alpha_price: I96F32 = Self::get_alpha_price(netuid);
+        let alpha_price: U96F32 = Self::get_alpha_price(netuid);
         log::debug!("{:?} - alpha_price: {:?}", netuid, alpha_price);
 
         // Get initial alpha_in
-        let mut alpha_in_emission: I96F32 = I96F32::saturating_from_num(tao_emission)
+        let mut alpha_in_emission: U96F32 = U96F32::saturating_from_num(tao_emission)
             .checked_div(alpha_price)
             .unwrap_or(float_alpha_block_emission);
 
@@ -60,11 +63,11 @@ impl<T: Config> Pallet<T> {
         }
 
         // Avoid rounding errors.
-        if tao_in_emission < I96F32::saturating_from_num(1)
-            || alpha_in_emission < I96F32::saturating_from_num(1)
+        if tao_in_emission < U96F32::saturating_from_num(1)
+            || alpha_in_emission < U96F32::saturating_from_num(1)
         {
-            alpha_in_emission = I96F32::saturating_from_num(0);
-            tao_in_emission = I96F32::saturating_from_num(0);
+            alpha_in_emission = U96F32::saturating_from_num(0);
+            tao_in_emission = U96F32::saturating_from_num(0);
         }
 
         // Set Alpha in emission.

pallets/subtensor/src/coinbase/block_step.rs

@@ -1,7 +1,7 @@
 use super::*;
 use frame_support::storage::IterableStorageMap;
 use safe_math::*;
-use substrate_fixed::types::{I96F32, I110F18};
+use substrate_fixed::types::{U96F32, U110F18};
 
 impl<T: Config + pallet_drand::Config> Pallet<T> {
     /// Executes the necessary operations for each block.
@@ -11,8 +11,8 @@ impl<T: Config + pallet_drand::Config> Pallet<T> {
         // --- 1. Adjust difficulties.
         Self::adjust_registration_terms_for_networks();
         // --- 2. Get the current coinbase emission.
-        let block_emission: I96F32 =
-            I96F32::saturating_from_num(Self::get_block_emission().unwrap_or(0));
+        let block_emission: U96F32 =
+            U96F32::saturating_from_num(Self::get_block_emission().unwrap_or(0));
         log::debug!("Block emission: {:?}", block_emission);
         // --- 3. Run emission through network.
         Self::run_coinbase(block_emission);
@@ -191,67 +191,67 @@ impl<T: Config + pallet_drand::Config> Pallet<T> {
     }
 
     /// Calculates the upgraded difficulty by multiplying the current difficulty by the ratio ( reg_actual + reg_target / reg_target + reg_target )
-    /// We use I110F18 to avoid any overflows on u64. Also min_difficulty and max_difficulty bound the range.
+    /// We use U110F18 to avoid any overflows on u64. Also min_difficulty and max_difficulty bound the range.
     ///
     pub fn upgraded_difficulty(
         netuid: u16,
         current_difficulty: u64,
         registrations_this_interval: u16,
         target_registrations_per_interval: u16,
     ) -> u64 {
-        let updated_difficulty: I110F18 = I110F18::saturating_from_num(current_difficulty)
-            .saturating_mul(I110F18::saturating_from_num(
+        let updated_difficulty: U110F18 = U110F18::saturating_from_num(current_difficulty)
+            .saturating_mul(U110F18::saturating_from_num(
                 registrations_this_interval.saturating_add(target_registrations_per_interval),
             ))
-            .safe_div(I110F18::saturating_from_num(
+            .safe_div(U110F18::saturating_from_num(
                 target_registrations_per_interval.saturating_add(target_registrations_per_interval),
             ));
-        let alpha: I110F18 = I110F18::saturating_from_num(Self::get_adjustment_alpha(netuid))
-            .safe_div(I110F18::saturating_from_num(u64::MAX));
-        let next_value: I110F18 = alpha
-            .saturating_mul(I110F18::saturating_from_num(current_difficulty))
+        let alpha: U110F18 = U110F18::saturating_from_num(Self::get_adjustment_alpha(netuid))
+            .safe_div(U110F18::saturating_from_num(u64::MAX));
+        let next_value: U110F18 = alpha
+            .saturating_mul(U110F18::saturating_from_num(current_difficulty))
             .saturating_add(
-                I110F18::saturating_from_num(1.0)
+                U110F18::saturating_from_num(1.0)
                     .saturating_sub(alpha)
                     .saturating_mul(updated_difficulty),
             );
-        if next_value >= I110F18::saturating_from_num(Self::get_max_difficulty(netuid)) {
+        if next_value >= U110F18::saturating_from_num(Self::get_max_difficulty(netuid)) {
             Self::get_max_difficulty(netuid)
-        } else if next_value <= I110F18::saturating_from_num(Self::get_min_difficulty(netuid)) {
+        } else if next_value <= U110F18::saturating_from_num(Self::get_min_difficulty(netuid)) {
             return Self::get_min_difficulty(netuid);
         } else {
             return next_value.saturating_to_num::<u64>();
         }
     }
 
     /// Calculates the upgraded burn by multiplying the current burn by the ratio ( reg_actual + reg_target / reg_target + reg_target )
-    /// We use I110F18 to avoid any overflows on u64. Also min_burn and max_burn bound the range.
+    /// We use U110F18 to avoid any overflows on u64. Also min_burn and max_burn bound the range.
     ///
     pub fn upgraded_burn(
         netuid: u16,
         current_burn: u64,
         registrations_this_interval: u16,
         target_registrations_per_interval: u16,
     ) -> u64 {
-        let updated_burn: I110F18 = I110F18::saturating_from_num(current_burn)
-            .saturating_mul(I110F18::saturating_from_num(
+        let updated_burn: U110F18 = U110F18::saturating_from_num(current_burn)
+            .saturating_mul(U110F18::saturating_from_num(
                 registrations_this_interval.saturating_add(target_registrations_per_interval),
             ))
-            .safe_div(I110F18::saturating_from_num(
+            .safe_div(U110F18::saturating_from_num(
                 target_registrations_per_interval.saturating_add(target_registrations_per_interval),
             ));
-        let alpha: I110F18 = I110F18::saturating_from_num(Self::get_adjustment_alpha(netuid))
-            .safe_div(I110F18::saturating_from_num(u64::MAX));
-        let next_value: I110F18 = alpha
-            .saturating_mul(I110F18::saturating_from_num(current_burn))
+        let alpha: U110F18 = U110F18::saturating_from_num(Self::get_adjustment_alpha(netuid))
+            .safe_div(U110F18::saturating_from_num(u64::MAX));
+        let next_value: U110F18 = alpha
+            .saturating_mul(U110F18::saturating_from_num(current_burn))
             .saturating_add(
-                I110F18::saturating_from_num(1.0)
+                U110F18::saturating_from_num(1.0)
                     .saturating_sub(alpha)
                     .saturating_mul(updated_burn),
             );
-        if next_value >= I110F18::saturating_from_num(Self::get_max_burn_as_u64(netuid)) {
+        if next_value >= U110F18::saturating_from_num(Self::get_max_burn_as_u64(netuid)) {
             Self::get_max_burn_as_u64(netuid)
-        } else if next_value <= I110F18::saturating_from_num(Self::get_min_burn_as_u64(netuid)) {
+        } else if next_value <= U110F18::saturating_from_num(Self::get_min_burn_as_u64(netuid)) {
             return Self::get_min_burn_as_u64(netuid);
         } else {
             return next_value.saturating_to_num::<u64>();