Merge pull request #1382 from opentensor/feat/burn-owner-uid

Burn miner emission to SNOwner hotkey

Author: sam0x17

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -266,8 +266,6 @@ impl<T: Config> Pallet<T> {
             pending_swapped,
             owner_cut
         );
-        // Setup.
-        let zero: I96F32 = asfloat!(0.0);
 
         // Run the epoch.
         let hotkey_emission: Vec<(T::AccountId, u64, u64)> =
@@ -297,6 +295,25 @@ impl<T: Config> Pallet<T> {
         log::debug!("incentives: {:?}", incentives);
         log::debug!("dividends: {:?}", dividends);
 
+        Self::distribute_dividends_and_incentives(
+            netuid,
+            pending_tao,
+            owner_cut,
+            incentives,
+            dividends,
+        );
+    }
+
+    pub fn distribute_dividends_and_incentives(
+        netuid: u16,
+        pending_tao: u64,
+        owner_cut: u64,
+        incentives: BTreeMap<T::AccountId, u64>,
+        dividends: BTreeMap<T::AccountId, I96F32>,
+    ) {
+        // Setup.
+        let zero: I96F32 = asfloat!(0.0);
+
         // Accumulate root divs and alpha_divs. For each hotkey we compute their
         // local and root dividend proportion based on their alpha_stake/root_stake
         let mut total_root_divs: I96F32 = asfloat!(0);
@@ -375,8 +392,19 @@ impl<T: Config> Pallet<T> {
 
         // Distribute mining incentives.
         for (hotkey, incentive) in incentives {
-            // Increase stake for miner.
             log::debug!("incentives: hotkey: {:?}", incentive);
+
+            if let Ok(owner_hotkey) = SubnetOwnerHotkey::<T>::try_get(netuid) {
+                if hotkey == owner_hotkey {
+                    log::debug!(
+                        "incentives: hotkey: {:?} is SN owner hotkey, skipping {:?}",
+                        hotkey,
+                        incentive
+                    );
+                    continue; // Skip/burn miner-emission for SN owner hotkey.
+                }
+            }
+            // Increase stake for miner.
             Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey.clone(),
                 &Owner::<T>::get(hotkey.clone()),

pallets/subtensor/src/epoch/math.rs

@@ -569,6 +569,33 @@ pub fn inplace_mask_diag(matrix: &mut [Vec<I32F32>]) {
     });
 }
 
+// Mask out the diagonal of the input matrix in-place, except for the diagonal entry at except_index.
+#[allow(dead_code)]
+pub fn inplace_mask_diag_except_index(matrix: &mut [Vec<I32F32>], except_index: u16) {
+    let Some(first_row) = matrix.first() else {
+        return;
+    };
+    if first_row.is_empty() {
+        return;
+    }
+    assert_eq!(matrix.len(), first_row.len());
+
+    let diag_at_index = matrix
+        .get(except_index as usize)
+        .and_then(|row| row.get(except_index as usize))
+        .cloned();
+
+    inplace_mask_diag(matrix);
+
+    matrix.get_mut(except_index as usize).map(|row| {
+        row.get_mut(except_index as usize).map(|value| {
+            if let Some(diag_at_index) = diag_at_index {
+                *value = diag_at_index;
+            }
+        })
+    });
+}
+
 // Return a new sparse matrix that replaces masked rows with an empty vector placeholder.
 #[allow(dead_code)]
 pub fn mask_rows_sparse(
@@ -604,6 +631,29 @@ pub fn mask_diag_sparse(sparse_matrix: &[Vec<(u16, I32F32)>]) -> Vec<Vec<(u16, I
         .collect()
 }
 
+// Return a new sparse matrix with a masked out diagonal of input sparse matrix,
+// except for the diagonal entry at except_index.
+#[allow(dead_code)]
+pub fn mask_diag_sparse_except_index(
+    sparse_matrix: &[Vec<(u16, I32F32)>],
+    except_index: u16,
+) -> Vec<Vec<(u16, I32F32)>> {
+    sparse_matrix
+        .iter()
+        .enumerate()
+        .map(|(i, sparse_row)| {
+            sparse_row
+                .iter()
+                .filter(|(j, _)| {
+                    // Is not a diagonal OR is the diagonal at except_index
+                    i != (*j as usize) || (i == except_index as usize && *j == except_index)
+                })
+                .copied()
+                .collect()
+        })
+        .collect()
+}
+
 // Remove cells from sparse matrix where the mask function of two vectors is true.
 #[allow(dead_code, clippy::indexing_slicing)]
 pub fn vec_mask_sparse_matrix(

pallets/subtensor/src/epoch/run_epoch.rs

@@ -111,6 +111,9 @@ impl<T: Config> Pallet<T> {
         // == Weights ==
         // =============
 
+        // Get owner uid.
+        let owner_uid: Option<u16> = Self::get_owner_uid(netuid);
+
         // Access network weights row unnormalized.
         let mut weights: Vec<Vec<I32F32>> = Self::get_weights(netuid);
         log::trace!("W:\n{:?}\n", &weights);
@@ -119,7 +122,13 @@ impl<T: Config> Pallet<T> {
         inplace_mask_rows(&validator_forbids, &mut weights);
         log::trace!("W (permit): {:?}", &weights);
 
-        // Remove self-weight by masking diagonal.
+        // Remove self-weight by masking diagonal; keep owner_uid self-weight.
+        if let Some(owner_uid) = owner_uid {
+            inplace_mask_diag_except_index(&mut weights, owner_uid);
+        } else {
+            inplace_mask_diag(&mut weights);
+        }
+
         inplace_mask_diag(&mut weights);
         log::trace!("W (permit+diag):\n{:?}\n", &weights);
 
@@ -454,6 +463,8 @@ impl<T: Config> Pallet<T> {
         // == Weights ==
         // =============
 
+        let owner_uid: Option<u16> = Self::get_owner_uid(netuid);
+
         // Access network weights row unnormalized.
         let mut weights: Vec<Vec<(u16, I32F32)>> = Self::get_weights_sparse(netuid);
         log::trace!("Weights: {:?}", &weights);
@@ -462,8 +473,12 @@ impl<T: Config> Pallet<T> {
         weights = mask_rows_sparse(&validator_forbids, &weights);
         log::trace!("Weights (permit): {:?}", &weights);
 
-        // Remove self-weight by masking diagonal.
-        weights = mask_diag_sparse(&weights);
+        // Remove self-weight by masking diagonal; keep owner_uid self-weight.
+        if let Some(owner_uid) = owner_uid {
+            weights = mask_diag_sparse_except_index(&weights, owner_uid);
+        } else {
+            weights = mask_diag_sparse(&weights);
+        }
         log::trace!("Weights (permit+diag): {:?}", &weights);
 
         // Remove weights referring to deregistered neurons.

pallets/subtensor/src/tests/coinbase.rs

@@ -2,6 +2,7 @@
 use super::mock::*;
 
 use crate::*;
+use alloc::collections::BTreeMap;
 use approx::assert_abs_diff_eq;
 use frame_support::assert_ok;
 use sp_core::U256;
@@ -1439,3 +1440,51 @@ fn test_get_root_children_drain_with_half_take() {
 //         );
 //     });
 // }
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::coinbase::test_incentive_to_subnet_owner_is_burned --exact --show-output --nocapture
+#[test]
+fn test_incentive_to_subnet_owner_is_burned() {
+    new_test_ext(1).execute_with(|| {
+        let subnet_owner_ck = U256::from(0);
+        let subnet_owner_hk = U256::from(1);
+
+        let other_ck = U256::from(2);
+        let other_hk = U256::from(3);
+
+        let netuid = add_dynamic_network(&subnet_owner_hk, &subnet_owner_ck);
+
+        let pending_tao: u64 = 1_000_000_000;
+        let owner_cut: u64 = 0;
+        let mut incentives: BTreeMap<U256, u64> = BTreeMap::new();
+        let mut dividends: BTreeMap<U256, I96F32> = BTreeMap::new();
+
+        // Give incentive to other_hk
+        incentives.insert(other_hk, 10_000_000);
+
+        // Give incentives to subnet_owner_hk
+        incentives.insert(subnet_owner_hk, 10_000_000);
+
+        // Verify stake before
+        let subnet_owner_stake_before =
+            SubtensorModule::get_stake_for_hotkey_on_subnet(&subnet_owner_hk, netuid);
+        assert_eq!(subnet_owner_stake_before, 0);
+        let other_stake_before = SubtensorModule::get_stake_for_hotkey_on_subnet(&other_hk, netuid);
+        assert_eq!(other_stake_before, 0);
+
+        // Distribute dividends and incentives
+        SubtensorModule::distribute_dividends_and_incentives(
+            netuid,
+            pending_tao,
+            owner_cut,
+            incentives,
+            dividends,
+        );
+
+        // Verify stake after
+        let subnet_owner_stake_after =
+            SubtensorModule::get_stake_for_hotkey_on_subnet(&subnet_owner_hk, netuid);
+        assert_eq!(subnet_owner_stake_after, 0);
+        let other_stake_after = SubtensorModule::get_stake_for_hotkey_on_subnet(&other_hk, netuid);
+        assert!(other_stake_after > 0);
+    });
+}

pallets/subtensor/src/tests/math.rs

@@ -58,7 +58,13 @@ fn assert_sparse_mat_compare(
 ) {
     assert!(ma.len() == mb.len());
     for row in 0..ma.len() {
-        assert!(ma[row].len() == mb[row].len());
+        assert!(
+            ma[row].len() == mb[row].len(),
+            "row: {}, ma: {:?}, mb: {:?}",
+            row,
+            ma[row],
+            mb[row]
+        );
         for j in 0..ma[row].len() {
             assert!(ma[row][j].0 == mb[row][j].0); // u16
             assert_float_compare(ma[row][j].1, mb[row][j].1, epsilon) // I32F32
@@ -1034,6 +1040,27 @@ fn test_math_inplace_mask_diag() {
     );
 }
 
+#[test]
+fn test_math_inplace_mask_diag_except_index() {
+    let vector: Vec<f32> = vec![1., 2., 3., 4., 5., 6., 7., 8., 9.];
+    let rows = 3;
+
+    for i in 0..rows {
+        let mut target: Vec<f32> = vec![0., 2., 3., 4., 0., 6., 7., 8., 0.];
+        let row = i * rows;
+        let col = i;
+        target[row + col] = vector[row + col];
+
+        let mut mat = vec_to_mat_fixed(&vector, rows, false);
+        inplace_mask_diag_except_index(&mut mat, i as u16);
+        assert_mat_compare(
+            &mat,
+            &vec_to_mat_fixed(&target, rows, false),
+            I32F32::from_num(0),
+        );
+    }
+}
+
 #[test]
 fn test_math_mask_rows_sparse() {
     let input: Vec<f32> = vec![1., 2., 3., 4., 5., 6., 7., 8., 9.];
@@ -1105,6 +1132,58 @@ fn test_math_mask_diag_sparse() {
     );
 }
 
+#[test]
+fn test_math_mask_diag_sparse_except_index() {
+    let rows = 3;
+
+    let vector: Vec<f32> = vec![1., 2., 3., 4., 5., 6., 7., 8., 9.];
+    let mat = vec_to_sparse_mat_fixed(&vector, rows, false);
+
+    for i in 0..rows {
+        let mut target: Vec<f32> = vec![0., 2., 3., 4., 0., 6., 7., 8., 0.];
+        let row = i * rows;
+        let col = i;
+        target[row + col] = vector[row + col];
+
+        let result = mask_diag_sparse_except_index(&mat, i as u16);
+        let target_as_mat = vec_to_sparse_mat_fixed(&target, rows, false);
+
+        assert_sparse_mat_compare(&result, &target_as_mat, I32F32::from_num(0));
+    }
+
+    let vector: Vec<f32> = vec![1., 0., 0., 0., 5., 0., 0., 0., 9.];
+    let mat = vec_to_sparse_mat_fixed(&vector, rows, false);
+
+    for i in 0..rows {
+        let mut target: Vec<f32> = vec![0., 0., 0., 0., 0., 0., 0., 0., 0.];
+        let row = i * rows;
+        let col = i;
+        target[row + col] = vector[row + col];
+
+        let result = mask_diag_sparse_except_index(&mat, i as u16);
+        let target_as_mat = vec_to_sparse_mat_fixed(&target, rows, false);
+        assert_eq!(result.len(), target_as_mat.len());
+
+        assert_sparse_mat_compare(&result, &target_as_mat, I32F32::from_num(0));
+    }
+
+    for i in 0..rows {
+        let vector: Vec<f32> = vec![0., 0., 0., 0., 0., 0., 0., 0., 0.];
+        let mat = vec_to_sparse_mat_fixed(&vector, rows, false);
+
+        let mut target: Vec<f32> = vec![0., 0., 0., 0., 0., 0., 0., 0., 0.];
+        let row = i * rows;
+        let col = i;
+        target[row + col] = vector[row + col];
+
+        let result = mask_diag_sparse_except_index(&mat, i as u16);
+        let target_as_mat = vec_to_sparse_mat_fixed(&target, rows, false);
+        assert_eq!(result.len(), target_as_mat.len());
+
+        assert_sparse_mat_compare(&result, &target_as_mat, I32F32::from_num(0));
+    }
+}
+
 #[test]
 fn test_math_vec_mask_sparse_matrix() {
     let vector: Vec<f32> = vec![1., 2., 3., 4., 5., 6., 7., 8., 9.];

pallets/subtensor/src/utils/misc.rs

@@ -733,4 +733,12 @@ impl<T: Config> Pallet<T> {
         SubnetOwnerHotkey::<T>::insert(netuid, hotkey.clone());
         Self::deposit_event(Event::SubnetOwnerHotkeySet(netuid, hotkey.clone()));
     }
+
+    // Get the uid of the Owner Hotkey for a subnet.
+    pub fn get_owner_uid(netuid: u16) -> Option<u16> {
+        match SubnetOwnerHotkey::<T>::try_get(netuid) {
+            Ok(owner_hotkey) => Uids::<T>::get(netuid, &owner_hotkey),
+            Err(_) => None,
+        }
+    }
 }