Merge pull request #864 from opentensor/commit-reveal-2

Commit-Reveal 2.0

Author: JohnReedV

pallets/admin-utils/src/benchmarking.rs

@@ -228,14 +228,14 @@ mod benchmarks {
     }
 
     #[benchmark]
-    fn sudo_set_commit_reveal_weights_interval() {
+    fn sudo_set_commit_reveal_weights_periods() {
         pallet_subtensor::Pallet::<T>::init_new_network(
             1u16, /*netuid*/
             1u16, /*sudo_tempo*/
         );
 
         #[extrinsic_call]
-		_(RawOrigin::Root, 1u16/*netuid*/, 3u64/*interval*/)/*set_commit_reveal_weights_interval()*/;
+		_(RawOrigin::Root, 1u16/*netuid*/, 3u64/*interval*/)/*set_commit_reveal_weights_periods()*/;
     }
 
     #[benchmark]

pallets/admin-utils/src/lib.rs

@@ -960,32 +960,6 @@ pub mod pallet {
             Ok(())
         }
 
-        /// The extrinsic sets the commit/reveal interval for a subnet.
-        /// It is only callable by the root account or subnet owner.
-        /// The extrinsic will call the Subtensor pallet to set the interval.
-        #[pallet::call_index(48)]
-        #[pallet::weight(T::WeightInfo::sudo_set_commit_reveal_weights_interval())]
-        pub fn sudo_set_commit_reveal_weights_interval(
-            origin: OriginFor<T>,
-            netuid: u16,
-            interval: u64,
-        ) -> DispatchResult {
-            pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
-
-            ensure!(
-                pallet_subtensor::Pallet::<T>::if_subnet_exist(netuid),
-                Error::<T>::SubnetDoesNotExist
-            );
-
-            pallet_subtensor::Pallet::<T>::set_commit_reveal_weights_interval(netuid, interval);
-            log::debug!(
-                "SetWeightCommitInterval( netuid: {:?}, interval: {:?} ) ",
-                netuid,
-                interval
-            );
-            Ok(())
-        }
-
         /// The extrinsic enabled/disables commit/reaveal for a given subnet.
         /// It is only callable by the root account or subnet owner.
         /// The extrinsic will call the Subtensor pallet to set the value.
@@ -1196,6 +1170,45 @@ pub mod pallet {
 
             Ok(())
         }
+
+        /// Sets the commit-reveal weights periods for a specific subnet.
+        ///
+        /// This extrinsic allows the subnet owner or root account to set the duration (in epochs) during which committed weights must be revealed.
+        /// The commit-reveal mechanism ensures that users commit weights in advance and reveal them only within a specified period.
+        ///
+        /// # Arguments
+        /// * `origin` - The origin of the call, which must be the subnet owner or the root account.
+        /// * `netuid` - The unique identifier of the subnet for which the periods are being set.
+        /// * `periods` - The number of epochs that define the commit-reveal period.
+        ///
+        /// # Errors
+        /// * `BadOrigin` - If the caller is neither the subnet owner nor the root account.
+        /// * `SubnetDoesNotExist` - If the specified subnet does not exist.
+        ///
+        /// # Weight
+        /// Weight is handled by the `#[pallet::weight]` attribute.
+        #[pallet::call_index(56)]
+        #[pallet::weight(T::WeightInfo::sudo_set_commit_reveal_weights_periods())]
+        pub fn sudo_set_commit_reveal_weights_periods(
+            origin: OriginFor<T>,
+            netuid: u16,
+            periods: u64,
+        ) -> DispatchResult {
+            pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
+
+            ensure!(
+                pallet_subtensor::Pallet::<T>::if_subnet_exist(netuid),
+                Error::<T>::SubnetDoesNotExist
+            );
+
+            pallet_subtensor::Pallet::<T>::set_reveal_period(netuid, periods);
+            log::debug!(
+                "SetWeightCommitPeriods( netuid: {:?}, periods: {:?} ) ",
+                netuid,
+                periods
+            );
+            Ok(())
+        }
     }
 }
 

pallets/admin-utils/src/weights.rs

@@ -60,7 +60,7 @@ pub trait WeightInfo {
 	fn sudo_set_min_burn() -> Weight;
 	fn sudo_set_network_registration_allowed() -> Weight;
 	fn sudo_set_tempo() -> Weight;
-	fn sudo_set_commit_reveal_weights_interval() -> Weight;
+	fn sudo_set_commit_reveal_weights_periods() -> Weight;
 	fn sudo_set_commit_reveal_weights_enabled() -> Weight;
 }
 
@@ -413,12 +413,12 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
-	fn sudo_set_commit_reveal_weights_interval() -> Weight {
+	fn sudo_set_commit_reveal_weights_periods() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1111`
-		//  Estimated: `4697`
-		// Minimum execution time: 46_450_000 picoseconds.
-		Weight::from_parts(47_279_000, 4697)
+		//  Measured:  `456`
+		//  Estimated: `3921`
+		// Minimum execution time: 19_070_000 picoseconds.
+		Weight::from_parts(19_380_000, 456)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -781,17 +781,17 @@ impl WeightInfo for () {
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
-	fn sudo_set_commit_reveal_weights_interval() -> Weight {
+	fn sudo_set_commit_reveal_weights_periods() -> Weight {
 		// -- Extrinsic Time --
 		// Model:
-		// Time ~=    20.42
-		//               µs
+		// Time ~=    19.38
+		// 			  µs
 		// Reads = 1
 		// Writes = 1
 		// Recorded proof Size = 456
-		Weight::from_parts(20_420_000, 456)
-			.saturating_add(RocksDbWeight::get().reads(1_u64))
-			.saturating_add(RocksDbWeight::get().writes(1_u64))
+		Weight::from_parts(19_380_000, 456)
+			.saturating_add(RocksDbWeight::get().reads(1))
+			.saturating_add(RocksDbWeight::get().writes(1))
 	}
 	fn sudo_set_commit_reveal_weights_enabled() -> Weight {
 		// -- Extrinsic Time --

pallets/admin-utils/tests/tests.rs

@@ -1113,29 +1113,6 @@ fn test_sudo_set_min_delegate_take() {
     });
 }
 
-#[test]
-fn test_sudo_set_weight_commit_interval() {
-    new_test_ext().execute_with(|| {
-        let netuid: u16 = 1;
-        add_network(netuid, 10);
-
-        let to_be_set = 55;
-        let init_value = SubtensorModule::get_commit_reveal_weights_interval(netuid);
-
-        assert_ok!(AdminUtils::sudo_set_commit_reveal_weights_interval(
-            <<Test as Config>::RuntimeOrigin>::root(),
-            netuid,
-            to_be_set
-        ));
-
-        assert!(init_value != to_be_set);
-        assert_eq!(
-            SubtensorModule::get_commit_reveal_weights_interval(netuid),
-            to_be_set
-        );
-    });
-}
-
 #[test]
 fn test_sudo_set_commit_reveal_weights_enabled() {
     new_test_ext().execute_with(|| {
@@ -1435,3 +1412,23 @@ fn test_sudo_set_dissolve_network_schedule_duration() {
         System::assert_last_event(Event::DissolveNetworkScheduleDurationSet(new_duration).into());
     });
 }
+
+#[test]
+fn sudo_set_commit_reveal_weights_periods() {
+    new_test_ext().execute_with(|| {
+        let netuid: u16 = 1;
+        add_network(netuid, 10);
+
+        let to_be_set = 55;
+        let init_value = SubtensorModule::get_reveal_period(netuid);
+
+        assert_ok!(AdminUtils::sudo_set_commit_reveal_weights_periods(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            netuid,
+            to_be_set
+        ));
+
+        assert!(init_value != to_be_set);
+        assert_eq!(SubtensorModule::get_reveal_period(netuid), to_be_set);
+    });
+}

pallets/subtensor/src/benchmarks.rs

@@ -416,7 +416,6 @@ reveal_weights {
     );
 
     Subtensor::<T>::set_validator_permit_for_uid(netuid, 0, true);
-    Subtensor::<T>::set_commit_reveal_weights_interval(netuid, 0);
 
     let commit_hash: H256 = BlakeTwo256::hash_of(&(
       hotkey.clone(),
@@ -521,4 +520,82 @@ reveal_weights {
     // Benchmark setup complete, now execute the extrinsic
 }: swap_coldkey(RawOrigin::Root, old_coldkey.clone(), new_coldkey.clone())
 
+batch_reveal_weights {
+  let tempo: u16 = 0;
+  let netuid: u16 = 1;
+  let num_commits: usize = 10;
+
+  let hotkey: T::AccountId = account("hot", 0, 1);
+  let coldkey: T::AccountId = account("cold", 0, 2);
+
+  Subtensor::<T>::init_new_network(netuid, tempo);
+  Subtensor::<T>::set_network_registration_allowed(netuid, true);
+  Subtensor::<T>::set_network_pow_registration_allowed(netuid, true);
+  Subtensor::<T>::set_commit_reveal_weights_enabled(netuid, true);
+  Subtensor::<T>::set_weights_set_rate_limit(netuid, 0); // Disable rate limiting for benchmarking
+
+  let block_number: u64 = Subtensor::<T>::get_current_block_as_u64();
+  let (nonce, work): (u64, Vec<u8>) = Subtensor::<T>::create_work_for_block_number(
+      netuid,
+      block_number,
+      3,
+      &hotkey,
+  );
+
+  let origin = T::RuntimeOrigin::from(RawOrigin::Signed(hotkey.clone()));
+  assert_ok!(Subtensor::<T>::register(
+      origin.clone(),
+      netuid,
+      block_number,
+      nonce,
+      work.clone(),
+      hotkey.clone(),
+      coldkey.clone(),
+  ));
+
+  let uid: u16 = 0;
+
+  Subtensor::<T>::set_validator_permit_for_uid(netuid, uid, true);
+
+  let mut uids_list = Vec::new();
+  let mut values_list = Vec::new();
+  let mut salts_list = Vec::new();
+  let mut version_keys = Vec::new();
+
+  for i in 0..num_commits {
+      let uids: Vec<u16> = vec![uid];
+      let values: Vec<u16> = vec![i as u16];
+      let salt: Vec<u16> = vec![i as u16];
+      let version_key_i: u64 = i as u64;
+
+      let commit_hash: H256 = BlakeTwo256::hash_of(&(
+          hotkey.clone(),
+          netuid,
+          uids.clone(),
+          values.clone(),
+          salt.clone(),
+          version_key_i,
+      ));
+
+      assert_ok!(Subtensor::<T>::commit_weights(
+          T::RuntimeOrigin::from(RawOrigin::Signed(hotkey.clone())),
+          netuid,
+          commit_hash,
+      ));
+
+      uids_list.push(uids);
+      values_list.push(values);
+      salts_list.push(salt);
+      version_keys.push(version_key_i);
+  }
+}: batch_reveal_weights(
+  RawOrigin::Signed(hotkey.clone()),
+  netuid,
+  uids_list,
+  values_list,
+  salts_list,
+  version_keys
+)
+
+
 }

pallets/subtensor/src/lib.rs

@@ -72,6 +72,7 @@ pub mod pallet {
     use frame_system::pallet_prelude::*;
     use sp_core::H256;
     use sp_runtime::traits::{Dispatchable, TrailingZeroInput};
+    use sp_std::collections::vec_deque::VecDeque;
     use sp_std::vec;
     use sp_std::vec::Vec;
     use subtensor_macros::freeze_struct;
@@ -568,6 +569,11 @@ pub mod pallet {
         0
     }
     #[pallet::type_value]
+    /// Default minimum stake for weights.
+    pub fn DefaultRevealPeriodEpochs<T: Config>() -> u64 {
+        1
+    }
+    #[pallet::type_value]
     /// Value definition for vector of u16.
     pub fn EmptyU16Vec<T: Config>() -> Vec<u16> {
         vec![]
@@ -629,11 +635,6 @@ pub mod pallet {
         T::InitialServingRateLimit::get()
     }
     #[pallet::type_value]
-    /// Default value for weight commit reveal interval.
-    pub fn DefaultWeightCommitRevealInterval<T: Config>() -> u64 {
-        1000
-    }
-    #[pallet::type_value]
     /// Default value for weight commit/reveal enabled.
     pub fn DefaultCommitRevealWeightsEnabled<T: Config>() -> bool {
         false
@@ -1032,10 +1033,6 @@ pub mod pallet {
         StorageMap<_, Identity, u16, u64, ValueQuery, DefaultAdjustmentAlpha<T>>;
     #[pallet::storage]
     /// --- MAP ( netuid ) --> interval
-    pub type WeightCommitRevealInterval<T> =
-        StorageMap<_, Identity, u16, u64, ValueQuery, DefaultWeightCommitRevealInterval<T>>;
-    #[pallet::storage]
-    /// --- MAP ( netuid ) --> interval
     pub type CommitRevealWeightsEnabled<T> =
         StorageMap<_, Identity, u16, bool, ValueQuery, DefaultCommitRevealWeightsEnabled<T>>;
     #[pallet::storage]
@@ -1254,16 +1251,20 @@ pub mod pallet {
     /// ITEM( weights_min_stake )
     pub type WeightsMinStake<T> = StorageValue<_, u64, ValueQuery, DefaultWeightsMinStake<T>>;
     #[pallet::storage]
-    /// --- MAP (netuid, who) --> (hash, weight) | Returns the hash and weight committed by an account for a given netuid.
+    /// --- MAP (netuid, who) --> VecDeque<(hash, commit_block)> | Stores a queue of commits for an account on a given netuid.
     pub type WeightCommits<T: Config> = StorageDoubleMap<
         _,
         Twox64Concat,
         u16,
         Twox64Concat,
         T::AccountId,
-        (H256, u64),
+        VecDeque<(H256, u64)>,
         OptionQuery,
     >;
+    #[pallet::storage]
+    /// --- Map (netuid) --> Number of epochs allowed for commit reveal periods
+    pub type RevealPeriodEpochs<T: Config> =
+        StorageMap<_, Twox64Concat, u16, u64, ValueQuery, DefaultRevealPeriodEpochs<T>>;
 
     /// ==================
     /// ==== Genesis =====
@@ -1460,6 +1461,18 @@ where
                     Err(InvalidTransaction::Custom(2).into())
                 }
             }
+            Some(Call::batch_reveal_weights { netuid, .. }) => {
+                if Self::check_weights_min_stake(who) {
+                    let priority: u64 = Self::get_priority_set_weights(who, *netuid);
+                    Ok(ValidTransaction {
+                        priority,
+                        longevity: 1,
+                        ..Default::default()
+                    })
+                } else {
+                    Err(InvalidTransaction::Custom(6).into())
+                }
+            }
             Some(Call::set_weights { netuid, .. }) => {
                 if Self::check_weights_min_stake(who) {
                     let priority: u64 = Self::get_priority_set_weights(who, *netuid);