add impl

Author: camfairchild

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -375,8 +375,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

@@ -604,6 +604,22 @@ 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)>> {
+    // Store the diagonal entry at except_index
+    let diag_at_index = sparse_matrix[except_index as usize][except_index as usize].clone();
+    // Mask out the diagonal
+    let mut result = mask_diag_sparse(sparse_matrix);
+    // Replace the diagonal entry at except_index
+    result[except_index as usize][except_index as usize] = diag_at_index;
+    result
+}
+
 // 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

@@ -454,6 +454,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 +464,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/utils/misc.rs

@@ -733,4 +733,14 @@ 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> {
+        let owner_hotkey = SubnetOwnerHotkey::<T>::get(netuid);
+        if Uids::<T>::contains_key(netuid, &owner_hotkey) {
+            Some(Uids::<T>::get(netuid, &owner_hotkey))
+        } else {
+            None
+        }
+    }
 }