Merge pull request #664 from opentensor/main-fix

Revert "Merge branch 'devnet-ready' into main"

Author: unconst

Cargo.lock

@@ -47,8 +47,4 @@ lint:
   @echo "Running cargo clippy with automatic fixes on potentially dirty code..."
   just clippy-fix
   @echo "Running cargo clippy..."
-  just clippy
-
-production:
-  @echo "Running cargo build with metadata-hash generation..."
-  cargo +{{RUSTV}} build --profile production --features="runtime-benchmarks metadata-hash"
+  just clippy

Cargo.toml

@@ -54,7 +54,6 @@ sp-io = { workspace = true }
 sp-timestamp = { workspace = true }
 sp-inherents = { workspace = true }
 sp-keyring = { workspace = true }
-frame-metadata-hash-extension = { workspace = true }
 frame-system = { workspace = true }
 pallet-transaction-payment = { workspace = true }
 pallet-commitments = { path = "../pallets/commitments" }

justfile

@@ -136,7 +136,6 @@ pub fn create_benchmark_extrinsic(
         pallet_transaction_payment::ChargeTransactionPayment::<runtime::Runtime>::from(0),
         pallet_subtensor::SubtensorSignedExtension::<runtime::Runtime>::new(),
         pallet_commitments::CommitmentsSignedExtension::<runtime::Runtime>::new(),
-        frame_metadata_hash_extension::CheckMetadataHash::<runtime::Runtime>::new(true),
     );
 
     let raw_payload = runtime::SignedPayload::from_raw(
@@ -153,7 +152,6 @@ pub fn create_benchmark_extrinsic(
             (),
             (),
             (),
-            None,
         ),
     );
     let signature = raw_payload.using_encoded(|e| sender.sign(e));

node/Cargo.toml

@@ -80,7 +80,7 @@ benchmarks! {
     // This is a whitelisted caller who can make transaction without weights.
     let caller: T::AccountId = whitelisted_caller::<AccountIdOf<T>>();
     let caller_origin = <T as frame_system::Config>::RuntimeOrigin::from(RawOrigin::Signed(caller.clone()));
-    let netuid: u16 = 0;
+    let netuid: u16 = 1;
     let version_key: u64 = 1;
     let tempo: u16 = 1;
     let modality: u16 = 0;

node/src/benchmarking.rs

@@ -188,6 +188,8 @@ impl<T: Config> Pallet<T> {
         // =================================
 
         // Compute emission scores.
+
+        // Compute normalized emission scores. range: I32F32(0, 1)
         // Compute normalized emission scores. range: I32F32(0, 1)
         let combined_emission: Vec<I32F32> = incentive
             .iter()

pallets/subtensor/src/benchmarks.rs

@@ -2045,10 +2045,9 @@ pub mod pallet {
 
         /// Attempt to adjust the senate membership to include a hotkey
         #[pallet::call_index(63)]
-        #[pallet::weight((Weight::from_parts(50_000_000, 0)
-        .saturating_add(Weight::from_parts(0, 4632))
-        .saturating_add(T::DbWeight::get().reads(5))
-        .saturating_add(T::DbWeight::get().writes(1)), DispatchClass::Normal, Pays::Yes))]
+        #[pallet::weight((Weight::from_parts(0, 0)
+		.saturating_add(T::DbWeight::get().reads(0))
+		.saturating_add(T::DbWeight::get().writes(0)), DispatchClass::Normal, Pays::Yes))]
         pub fn adjust_senate(origin: OriginFor<T>, hotkey: T::AccountId) -> DispatchResult {
             Self::do_adjust_senate(origin, hotkey)
         }

pallets/subtensor/src/epoch.rs

@@ -889,48 +889,59 @@ pub fn weighted_median(
     score: &[I32F32],
     partition_idx: &[usize],
     minority: I32F32,
-    mut partition_lo: I32F32,
-    mut partition_hi: I32F32,
+    partition_lo: I32F32,
+    partition_hi: I32F32,
 ) -> I32F32 {
-    let mut current_partition_idx = partition_idx.to_vec();
-    while !current_partition_idx.is_empty() {
-        let n = current_partition_idx.len();
-        if n == 1 {
-            return score[current_partition_idx[0]];
-        }
-        let mid_idx: usize = n.saturating_div(2);
-        let pivot: I32F32 = score[current_partition_idx[mid_idx]];
-        let mut lo_stake: I32F32 = I32F32::from_num(0);
-        let mut hi_stake: I32F32 = I32F32::from_num(0);
-        let mut lower: Vec<usize> = vec![];
-        let mut upper: Vec<usize> = vec![];
-        for &idx in &current_partition_idx {
-            if score[idx] == pivot {
-                continue;
-            }
-            if score[idx] < pivot {
-                lo_stake = lo_stake.saturating_add(stake[idx]);
-                lower.push(idx);
-            } else {
-                hi_stake = hi_stake.saturating_add(stake[idx]);
-                upper.push(idx);
-            }
+    let n = partition_idx.len();
+    if n == 0 {
+        return I32F32::from_num(0);
+    }
+    if n == 1 {
+        return score[partition_idx[0]];
+    }
+    assert!(stake.len() == score.len());
+    let mid_idx: usize = n.saturating_div(2);
+    let pivot: I32F32 = score[partition_idx[mid_idx]];
+    let mut lo_stake: I32F32 = I32F32::from_num(0);
+    let mut hi_stake: I32F32 = I32F32::from_num(0);
+    let mut lower: Vec<usize> = vec![];
+    let mut upper: Vec<usize> = vec![];
+    for &idx in partition_idx {
+        if score[idx] == pivot {
+            continue;
         }
-        if partition_lo.saturating_add(lo_stake) <= minority
-            && minority < partition_hi.saturating_sub(hi_stake)
-        {
-            return pivot;
-        } else if (minority < partition_lo.saturating_add(lo_stake)) && (!lower.is_empty()) {
-            current_partition_idx = lower;
-            partition_hi = partition_lo.saturating_add(lo_stake);
-        } else if (partition_hi.saturating_sub(hi_stake) <= minority) && (!upper.is_empty()) {
-            current_partition_idx = upper;
-            partition_lo = partition_hi.saturating_sub(hi_stake);
+        if score[idx] < pivot {
+            lo_stake = lo_stake.saturating_add(stake[idx]);
+            lower.push(idx);
         } else {
-            return pivot;
+            hi_stake = hi_stake.saturating_add(stake[idx]);
+            upper.push(idx);
         }
     }
-    I32F32::from_num(0)
+    if (partition_lo.saturating_add(lo_stake) <= minority)
+        && (minority < partition_hi.saturating_sub(hi_stake))
+    {
+        return pivot;
+    } else if (minority < partition_lo.saturating_add(lo_stake)) && (!lower.is_empty()) {
+        return weighted_median(
+            stake,
+            score,
+            &lower,
+            minority,
+            partition_lo,
+            partition_lo.saturating_add(lo_stake),
+        );
+    } else if (partition_hi.saturating_sub(hi_stake) <= minority) && (!upper.is_empty()) {
+        return weighted_median(
+            stake,
+            score,
+            &upper,
+            minority,
+            partition_hi.saturating_sub(hi_stake),
+            partition_hi,
+        );
+    }
+    pivot
 }
 
 /// Column-wise weighted median, e.g. stake-weighted median scores per server (column) over all validators (rows).

pallets/subtensor/src/lib.rs

@@ -1,13 +1,12 @@
 #![allow(clippy::arithmetic_side_effects, clippy::unwrap_used)]
-
+use frame_support::derive_impl;
+use frame_support::dispatch::DispatchResultWithPostInfo;
+use frame_support::weights::constants::RocksDbWeight;
 // use frame_support::weights::constants::WEIGHT_PER_SECOND;
 use frame_support::weights::Weight;
 use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::DispatchResultWithPostInfo,
-    parameter_types,
+    assert_ok, parameter_types,
     traits::{Everything, Hooks},
-    weights::constants::RocksDbWeight,
 };
 use frame_system as system;
 use frame_system::{limits, EnsureNever, EnsureRoot, RawOrigin};