Merge pull request #1862 from opentensor/block-based-weight-mask-dereg-uids

Block-Based Commit-Reveal Weight Masking for Deregistered UIDs

Author: sam0x17

pallets/subtensor/src/coinbase/reveal_commits.rs

@@ -34,9 +34,9 @@ impl<T: Config> Pallet<T> {
             cur_epoch.saturating_sub(Self::get_reveal_period(netuid).saturating_sub(1));
 
         // Clean expired commits
-        for (epoch, _) in CRV3WeightCommits::<T>::iter_prefix(netuid) {
+        for (epoch, _) in CRV3WeightCommitsV2::<T>::iter_prefix(netuid) {
             if epoch < reveal_epoch {
-                CRV3WeightCommits::<T>::remove(netuid, epoch);
+                CRV3WeightCommitsV2::<T>::remove(netuid, epoch);
             }
         }
 
@@ -46,10 +46,12 @@ impl<T: Config> Pallet<T> {
             return Ok(());
         }
 
-        let mut entries = CRV3WeightCommits::<T>::take(netuid, reveal_epoch);
+        let mut entries = CRV3WeightCommitsV2::<T>::take(netuid, reveal_epoch);
 
         // Keep popping item off the end of the queue until we sucessfully reveal a commit.
-        while let Some((who, serialized_compresssed_commit, round_number)) = entries.pop_front() {
+        while let Some((who, _commit_block, serialized_compresssed_commit, round_number)) =
+            entries.pop_front()
+        {
             let reader = &mut &serialized_compresssed_commit[..];
             let commit = match TLECiphertext::<TinyBLS381>::deserialize_compressed(reader) {
                 Ok(c) => c,

pallets/subtensor/src/epoch/run_epoch.rs

@@ -584,28 +584,49 @@ impl<T: Config> Pallet<T> {
         log::trace!("Weights (permit+diag+outdate): {:?}", &weights);
 
         if Self::get_commit_reveal_weights_enabled(netuid) {
-            // Precompute safe blocks for all UIDs
-            let safe_blocks: Vec<u64> = block_at_registration
-                .iter()
-                .map(|reg_block| {
-                    let reg_epoch = Self::get_epoch_index(netuid, *reg_block);
-                    let safe_epoch =
-                        reg_epoch.saturating_add(Self::get_reveal_period(netuid).saturating_mul(2));
+            let mut commit_blocks: Vec<u64> = vec![u64::MAX; n as usize]; // MAX ⇒ “no active commit”
 
-                    Self::get_first_block_of_epoch(netuid, safe_epoch)
-                })
-                .collect();
+            // helper: hotkey → uid
+            let uid_of = |acct: &T::AccountId| -> Option<usize> {
+                hotkeys
+                    .iter()
+                    .find(|(_, a)| a == acct)
+                    .map(|(uid, _)| *uid as usize)
+            };
+
+            // ---------- v2 ------------------------------------------------------
+            for (who, q) in WeightCommits::<T>::iter_prefix(netuid) {
+                for (_, cb, _, _) in q.iter() {
+                    if !Self::is_commit_expired(netuid, *cb) {
+                        if let Some(i) = uid_of(&who) {
+                            commit_blocks[i] = commit_blocks[i].min(*cb);
+                        }
+                        break; // earliest active found
+                    }
+                }
+            }
+
+            // ---------- v3 ------------------------------------------------------
+            for (_epoch, q) in CRV3WeightCommitsV2::<T>::iter_prefix(netuid) {
+                for (who, cb, ..) in q.iter() {
+                    if !Self::is_commit_expired(netuid, *cb) {
+                        if let Some(i) = uid_of(who) {
+                            commit_blocks[i] = commit_blocks[i].min(*cb);
+                        }
+                    }
+                }
+            }
 
-            // Mask out weights to recently registered UIDs
             weights = vec_mask_sparse_matrix(
                 &weights,
-                &last_update,
-                &safe_blocks,
-                &|updated, safe_block| updated < safe_block,
+                &commit_blocks,
+                &block_at_registration,
+                &|cb, reg| cb < reg,
             );
 
             log::trace!(
-                "Masking weights to miners inside reveal window (recent registrations masked)"
+                "Commit-reveal column mask applied ({} masked rows)",
+                commit_blocks.iter().filter(|&&cb| cb != u64::MAX).count()
             );
         }
 

pallets/subtensor/src/lib.rs

@@ -1646,15 +1646,33 @@ pub mod pallet {
         OptionQuery,
     >;
     #[pallet::storage]
-    /// --- MAP (netuid, commit_epoch) --> VecDeque<(who, serialized_compressed_commit, reveal_round)> | Stores a queue of v3 commits for an account on a given netuid.
+    /// MAP (netuid, epoch) → VecDeque<(who, ciphertext, reveal_round)>
+    /// DEPRECATED for CRV3WeightCommitsV2
     pub type CRV3WeightCommits<T: Config> = StorageDoubleMap<
         _,
         Twox64Concat,
         NetUid,
         Twox64Concat,
-        u64,
+        u64, // epoch key
+        VecDeque<(
+            T::AccountId,
+            BoundedVec<u8, ConstU32<MAX_CRV3_COMMIT_SIZE_BYTES>>,
+            RoundNumber,
+        )>,
+        ValueQuery,
+    >;
+    #[pallet::storage]
+    /// MAP (netuid, epoch) → VecDeque<(who, commit_block, ciphertext, reveal_round)>
+    /// Stores a queue of v3 commits for an account on a given netuid.
+    pub type CRV3WeightCommitsV2<T: Config> = StorageDoubleMap<
+        _,
+        Twox64Concat,
+        NetUid,
+        Twox64Concat,
+        u64, // epoch key
         VecDeque<(
             T::AccountId,
+            u64, // commit_block
             BoundedVec<u8, ConstU32<MAX_CRV3_COMMIT_SIZE_BYTES>>,
             RoundNumber,
         )>,

pallets/subtensor/src/macros/hooks.rs

@@ -127,7 +127,9 @@ mod hooks {
                 // Migrate Subnet Identities to V3
                 .saturating_add(migrations::migrate_subnet_identities_to_v3::migrate_subnet_identities_to_v3::<T>())
                 // Migrate subnet symbols to fix the shift after subnet 81
-                .saturating_add(migrations::migrate_subnet_symbols::migrate_subnet_symbols::<T>());
+                .saturating_add(migrations::migrate_subnet_symbols::migrate_subnet_symbols::<T>())
+                // Migrate CRV3 add commit_block
+                .saturating_add(migrations::migrate_crv3_commits_add_block::migrate_crv3_commits_add_block::<T>());
             weight
         }
 

pallets/subtensor/src/migrations/migrate_crv3_commits_add_block.rs

@@ -0,0 +1,49 @@
+use super::*;
+use frame_support::{traits::Get, weights::Weight};
+use log;
+use scale_info::prelude::string::String;
+use sp_std::collections::vec_deque::VecDeque;
+
+/// --------------- Migration ------------------------------------------
+/// Upgrades every entry to the new 4-tuple layout by inserting
+/// `commit_block = first_block_of_epoch(netuid, epoch)`.
+pub fn migrate_crv3_commits_add_block<T: Config>() -> Weight {
+    let mig_name: Vec<u8> = b"crv3_commits_add_block_v1".to_vec();
+    let mut total_weight = T::DbWeight::get().reads(1);
+
+    // run once
+    if HasMigrationRun::<T>::get(&mig_name) {
+        log::info!(
+            "Migration '{}' already executed - skipping",
+            String::from_utf8_lossy(&mig_name)
+        );
+        return total_weight;
+    }
+    log::info!("Running migration '{}'", String::from_utf8_lossy(&mig_name));
+
+    // iterate over *all* (netuid, epoch, queue) triples
+    for (netuid, epoch, old_q) in CRV3WeightCommits::<T>::drain() {
+        total_weight = total_weight.saturating_add(T::DbWeight::get().reads_writes(1, 1));
+
+        let commit_block = Pallet::<T>::get_first_block_of_epoch(netuid, epoch);
+
+        // convert VecDeque<(who,cipher,rnd)> → VecDeque<(who,cb,cipher,rnd)>
+        let new_q: VecDeque<_> = old_q
+            .into_iter()
+            .map(|(who, cipher, rnd)| (who, commit_block, cipher, rnd))
+            .collect();
+
+        // write back under *new* storage definition
+        CRV3WeightCommitsV2::<T>::insert(netuid, epoch, new_q);
+    }
+
+    // mark as done
+    HasMigrationRun::<T>::insert(&mig_name, true);
+    total_weight = total_weight.saturating_add(T::DbWeight::get().writes(1));
+
+    log::info!(
+        "Migration '{}' completed",
+        String::from_utf8_lossy(&mig_name)
+    );
+    total_weight
+}

pallets/subtensor/src/migrations/mod.rs

@@ -8,6 +8,7 @@ pub mod migrate_chain_identity;
 pub mod migrate_coldkey_swap_scheduled;
 pub mod migrate_commit_reveal_v2;
 pub mod migrate_create_root_network;
+pub mod migrate_crv3_commits_add_block;
 pub mod migrate_delete_subnet_21;
 pub mod migrate_delete_subnet_3;
 pub mod migrate_fix_is_network_member;

pallets/subtensor/src/subnets/weights.rs

@@ -269,12 +269,12 @@ impl<T: Config> Pallet<T> {
             false => Self::get_epoch_index(netuid, cur_block),
         };
 
-        CRV3WeightCommits::<T>::try_mutate(netuid, cur_epoch, |commits| -> DispatchResult {
+        CRV3WeightCommitsV2::<T>::try_mutate(netuid, cur_epoch, |commits| -> DispatchResult {
             // 6. Verify that the number of unrevealed commits is within the allowed limit.
 
             let unrevealed_commits_for_who = commits
                 .iter()
-                .filter(|(account, _, _)| account == &who)
+                .filter(|(account, _, _, _)| account == &who)
                 .count();
             ensure!(
                 unrevealed_commits_for_who < 10,
@@ -284,7 +284,7 @@ impl<T: Config> Pallet<T> {
             // 7. Append the new commit with calculated reveal blocks.
             // Hash the commit before it is moved, for the event
             let commit_hash = BlakeTwo256::hash(&commit);
-            commits.push_back((who.clone(), commit, reveal_round));
+            commits.push_back((who.clone(), cur_block, commit, reveal_round));
 
             // 8. Emit the WeightsCommitted event
             Self::deposit_event(Event::CRV3WeightsCommitted(