Merge pull request #2244 from opentensor/fix-cargo-audit

Fix cargo audit

Author: sam0x17

.github/workflows/cargo-audit.yml

@@ -46,4 +46,6 @@ jobs:
           cargo audit --ignore RUSTSEC-2023-0091 \
                       --ignore RUSTSEC-2024-0438 \
                       --ignore RUSTSEC-2025-0009 \
-                      --ignore RUSTSEC-2025-0055
+                      --ignore RUSTSEC-2025-0055 \
+                      --ignore RUSTSEC-2025-0073 \
+                      --ignore RUSTSEC-2025-0118

.github/workflows/check-rust.yml

@@ -38,7 +38,7 @@ jobs:
       - name: Install Rust Nightly
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly
+          toolchain: stable
           components: rustfmt
 
       - name: Utilize Shared Rust Cache
@@ -48,7 +48,22 @@ jobs:
           cache-on-failure: true
 
       - name: cargo fmt
-        run: cargo +nightly fmt --check --all
+        run: |
+          set -euo pipefail
+          # Run cargo fmt and capture both stdout and stderr
+          output=$(cargo fmt --check --all 2>&1) || {
+            echo "❌ cargo fmt failed with non-zero exit code"
+            echo "$output"
+            exit 1
+          }
+          # Check for panic/ICE messages even if exit code was 0
+          if echo "$output" | grep -qiE "(the compiler unexpectedly panicked|panicked at|Internal Compiler Error|ICE|error: the compiler unexpectedly panicked)"; then
+            echo "❌ rustfmt panicked (ICE detected) - this should fail the build"
+            echo "$output"
+            exit 1
+          fi
+          echo "$output"
+          echo "✅ cargo fmt completed successfully"
 
   cargo-clippy-default-features:
     name: cargo clippy

chain-extensions/src/tests.rs

@@ -757,12 +757,12 @@ impl SubtensorExtensionEnv<AccountId> for MockEnv {
     }
 
     fn charge_weight(&mut self, weight: Weight) -> Result<(), DispatchError> {
-        if let Some(expected) = self.expected_weight {
-            if weight != expected {
-                return Err(DispatchError::Other(
-                    "unexpected weight charged by mock env",
-                ));
-            }
+        if let Some(expected) = self.expected_weight
+            && weight != expected
+        {
+            return Err(DispatchError::Other(
+                "unexpected weight charged by mock env",
+            ));
         }
         self.charged_weight = Some(weight);
         Ok(())

node/src/command.rs

@@ -272,7 +272,7 @@ fn start_babe_service(arg_matches: &ArgMatches) -> Result<(), sc_cli::Error> {
             {
                 log::info!("Failed to aquire DB lock, trying again in 1s...");
                 std::thread::sleep(std::time::Duration::from_secs(1));
-                return start_babe_service(arg_matches);
+                start_babe_service(arg_matches)
             // Unknown error, return it.
             } else {
                 log::error!("Failed to start Babe service: {e:?}");

node/src/consensus/aura_consensus.rs

@@ -120,7 +120,7 @@ impl ConsensusMechanism for AuraConsensus {
         Self {}
     }
 
-    fn build_biq(&mut self) -> Result<BIQ, sc_service::Error>
+    fn build_biq(&mut self) -> Result<BIQ<'_>, sc_service::Error>
     where
         NumberFor<Block>: BlockNumberOps,
     {

node/src/consensus/babe_consensus.rs

@@ -128,7 +128,7 @@ impl ConsensusMechanism for BabeConsensus {
         }
     }
 
-    fn build_biq(&mut self) -> Result<BIQ, sc_service::Error>
+    fn build_biq(&mut self) -> Result<BIQ<'_>, sc_service::Error>
     where
         NumberFor<Block>: BlockNumberOps,
     {

node/src/consensus/consensus_mechanism.rs

@@ -77,7 +77,7 @@ pub trait ConsensusMechanism {
     fn new() -> Self;
 
     /// Builds a `BIQ` that uses the ConsensusMechanism.
-    fn build_biq(&mut self) -> Result<BIQ, sc_service::Error>;
+    fn build_biq(&mut self) -> Result<BIQ<'_>, sc_service::Error>;
 
     /// Returns the slot duration.
     fn slot_duration(&self, client: &FullClient) -> Result<SlotDuration, ServiceError>;

pallets/subtensor/src/coinbase/block_step.rs

@@ -229,9 +229,9 @@ impl<T: Config + pallet_drand::Config> Pallet<T> {
         if next_value >= U110F18::saturating_from_num(Self::get_max_difficulty(netuid)) {
             Self::get_max_difficulty(netuid)
         } else if next_value <= U110F18::saturating_from_num(Self::get_min_difficulty(netuid)) {
-            return Self::get_min_difficulty(netuid);
+            Self::get_min_difficulty(netuid)
         } else {
-            return next_value.saturating_to_num::<u64>();
+            next_value.saturating_to_num::<u64>()
         }
     }
 
@@ -263,9 +263,9 @@ impl<T: Config + pallet_drand::Config> Pallet<T> {
         if next_value >= U110F18::saturating_from_num(Self::get_max_burn(netuid)) {
             Self::get_max_burn(netuid)
         } else if next_value <= U110F18::saturating_from_num(Self::get_min_burn(netuid)) {
-            return Self::get_min_burn(netuid);
+            Self::get_min_burn(netuid)
         } else {
-            return next_value.saturating_to_num::<u64>().into();
+            next_value.saturating_to_num::<u64>().into()
         }
     }
 

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -491,10 +491,11 @@ impl<T: Config> Pallet<T> {
 
         // Insert subnet owner hotkey in the beginning of the list if valid and not
         // already present
-        if let Ok(owner_hk) = SubnetOwnerHotkey::<T>::try_get(netuid) {
-            if Uids::<T>::get(netuid, &owner_hk).is_some() && !owner_hotkeys.contains(&owner_hk) {
-                owner_hotkeys.insert(0, owner_hk);
-            }
+        if let Ok(owner_hk) = SubnetOwnerHotkey::<T>::try_get(netuid)
+            && Uids::<T>::get(netuid, &owner_hk).is_some()
+            && !owner_hotkeys.contains(&owner_hk)
+        {
+            owner_hotkeys.insert(0, owner_hk);
         }
 
         owner_hotkeys
@@ -508,22 +509,22 @@ impl<T: Config> Pallet<T> {
         root_alpha_dividends: BTreeMap<T::AccountId, U96F32>,
     ) {
         // Distribute the owner cut.
-        if let Ok(owner_coldkey) = SubnetOwner::<T>::try_get(netuid) {
-            if let Ok(owner_hotkey) = SubnetOwnerHotkey::<T>::try_get(netuid) {
-                // Increase stake for owner hotkey and coldkey.
-                log::debug!(
-                    "owner_hotkey: {owner_hotkey:?} owner_coldkey: {owner_coldkey:?}, owner_cut: {owner_cut:?}"
-                );
-                let real_owner_cut = Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
-                    &owner_hotkey,
-                    &owner_coldkey,
-                    netuid,
-                    owner_cut,
-                );
-                // If the subnet is leased, notify the lease logic that owner cut has been distributed.
-                if let Some(lease_id) = SubnetUidToLeaseId::<T>::get(netuid) {
-                    Self::distribute_leased_network_dividends(lease_id, real_owner_cut);
-                }
+        if let Ok(owner_coldkey) = SubnetOwner::<T>::try_get(netuid)
+            && let Ok(owner_hotkey) = SubnetOwnerHotkey::<T>::try_get(netuid)
+        {
+            // Increase stake for owner hotkey and coldkey.
+            log::debug!(
+                "owner_hotkey: {owner_hotkey:?} owner_coldkey: {owner_coldkey:?}, owner_cut: {owner_cut:?}"
+            );
+            let real_owner_cut = Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
+                &owner_hotkey,
+                &owner_coldkey,
+                netuid,
+                owner_cut,
+            );
+            // If the subnet is leased, notify the lease logic that owner cut has been distributed.
+            if let Some(lease_id) = SubnetUidToLeaseId::<T>::get(netuid) {
+                Self::distribute_leased_network_dividends(lease_id, real_owner_cut);
             }
         }
 

pallets/subtensor/src/epoch/math.rs

@@ -335,10 +335,10 @@ pub fn inplace_row_normalize_sparse(sparse_matrix: &mut [Vec<(u16, I32F32)>]) {
 
 // Sum across each row (dim=0) of a matrix.
 pub fn row_sum(x: &[Vec<I32F32>]) -> Vec<I32F32> {
-    if let Some(first_row) = x.first() {
-        if first_row.is_empty() {
-            return vec![];
-        }
+    if let Some(first_row) = x.first()
+        && first_row.is_empty()
+    {
+        return vec![];
     }
     x.iter().map(|row| row.iter().sum()).collect()
 }
@@ -424,10 +424,10 @@ pub fn inplace_col_max_upscale_sparse(sparse_matrix: &mut [Vec<(u16, I32F32)>],
     // Pass 1: compute per-column max
     for sparse_row in sparse_matrix.iter() {
         for (j, value) in sparse_row.iter() {
-            if let Some(m) = col_max.get_mut(*j as usize) {
-                if *m < *value {
-                    *m = *value;
-                }
+            if let Some(m) = col_max.get_mut(*j as usize)
+                && *m < *value
+            {
+                *m = *value;
             }
         }
     }
@@ -1147,10 +1147,10 @@ pub fn weighted_median_col_sparse(
     while let (Some(&s), Some(sparse_row)) = (stake_it.next(), score_it.next()) {
         if s > zero {
             for &(c, val) in sparse_row.iter() {
-                if let Some(col_vec) = use_score.get_mut(c as usize) {
-                    if let Some(cell) = col_vec.get_mut(k) {
-                        *cell = val;
-                    }
+                if let Some(col_vec) = use_score.get_mut(c as usize)
+                    && let Some(cell) = col_vec.get_mut(k)
+                {
+                    *cell = val;
                 }
             }
             k = k.saturating_add(1);
@@ -1289,10 +1289,10 @@ pub fn interpolate_sparse(
             let v1 = row1.get(j).unwrap_or(&zero);
             let v2 = row2.get(j).unwrap_or(&zero);
             let interp = v1.saturating_add(ratio.saturating_mul(v2.saturating_sub(*v1)));
-            if zero < interp {
-                if let Some(res) = result.get_mut(i) {
-                    res.push((j as u16, interp));
-                }
+            if zero < interp
+                && let Some(res) = result.get_mut(i)
+            {
+                res.push((j as u16, interp));
             }
         }
     }
@@ -1338,10 +1338,10 @@ pub fn mat_vec_mul_sparse(
         for (j, value) in matrix_row.iter() {
             if let Some(vector_value) = vector.get(*j as usize) {
                 let new_value = value.saturating_mul(*vector_value);
-                if new_value != I32F32::saturating_from_num(0.0) {
-                    if let Some(result_row) = result.get_mut(i) {
-                        result_row.push((*j, new_value));
-                    }
+                if new_value != I32F32::saturating_from_num(0.0)
+                    && let Some(result_row) = result.get_mut(i)
+                {
+                    result_row.push((*j, new_value));
                 }
             }
         }