Merge pull request #2141 from opentensor/disable-max-weight-limit

Remove hyperparameter max_weight_limit

Author: sam0x17

evm-tests/src/contracts/subnet.ts

@@ -663,24 +663,6 @@ export const ISubnetABI = [
         stateMutability: "payable",
         type: "function",
     },
-    {
-        inputs: [
-            {
-                internalType: "uint16",
-                name: "netuid",
-                type: "uint16",
-            },
-            {
-                internalType: "uint16",
-                name: "maxWeightLimit",
-                type: "uint16",
-            },
-        ],
-        name: "setMaxWeightLimit",
-        outputs: [],
-        stateMutability: "payable",
-        type: "function",
-    },
     {
         inputs: [
             {

evm-tests/test/subnet.precompile.hyperparameter.test.ts

@@ -208,25 +208,17 @@ describe("Test the Subnet precompile contract", () => {
         assert.equal(valueFromContract, onchainValue);
     })
 
-    it("Can set maxWeightLimit parameter", async () => {
+    it("Returns constant maxWeightLimit", async () => {
 
         const totalNetwork = await api.query.SubtensorModule.TotalNetworks.getValue()
         const contract = new ethers.Contract(ISUBNET_ADDRESS, ISubnetABI, wallet);
         const netuid = totalNetwork - 1;
 
-        const newValue = 106;
-        const tx = await contract.setMaxWeightLimit(netuid, newValue);
-        await tx.wait();
-
-        let onchainValue = await api.query.SubtensorModule.MaxWeightsLimit.getValue(netuid)
-
-
-        let valueFromContract = Number(
+        const valueFromContract = Number(
             await contract.getMaxWeightLimit(netuid)
         );
 
-        assert.equal(valueFromContract, newValue)
-        assert.equal(valueFromContract, onchainValue);
+        assert.equal(valueFromContract, 0xFFFF)
     })
 
     it("Can set immunityPeriod parameter", async () => {

hyperparameters.md

@@ -2,6 +2,7 @@
 ```rust
 DefaultTake: u16 = 11_796; // 18% honest number.
 TxRateLimit: u64 = 1; // [1 @ 64,888]
+MaxWeightsLimit: u16 = u16::MAX; // constant limit
 ```
 
 ### netuid 1 (text_prompting)
@@ -13,7 +14,6 @@ MaxAllowedUids: u16 = 1024;
 Issuance: u64 = 0;
 MinAllowedWeights: u16 = 8;
 EmissionValue: u64 = 142_223_000;
-MaxWeightsLimit: 455; // 455/2^16 = 0.0069
 ValidatorBatchSize: u16 = 1;
 ValidatorSequenceLen: u16 = 2048; // 2048
 ValidatorEpochLen: u16 = 100;
@@ -54,7 +54,6 @@ MaxAllowedUids: u16 = 4096;
 Issuance: u64 = 0;
 MinAllowedWeights: u16 = 50;
 EmissionValue: u64 = 857_777_000;
-MaxWeightsLimit: u16 = 655; // 655/2^16 = 0.01 [655 @ 7,160]
 ValidatorBatchSize: u16 = 32; // 32
 ValidatorSequenceLen: u16 = 256; // 256
 ValidatorEpochLen: u16 = 250; // [250 @ 7,161]

pallets/admin-utils/src/benchmarking.rs

@@ -292,19 +292,6 @@ mod benchmarks {
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 100u16/*immunity_period*/)/*sudo_set_immunity_period*/;
     }
 
-    #[benchmark]
-    fn sudo_set_max_weight_limit() {
-        // disable admin freeze window
-        pallet_subtensor::Pallet::<T>::set_admin_freeze_window(0);
-        pallet_subtensor::Pallet::<T>::init_new_network(
-            1u16.into(), /*netuid*/
-            1u16,        /*tempo*/
-        );
-
-        #[extrinsic_call]
-		_(RawOrigin::Root, 1u16.into()/*netuid*/, 100u16/*max_weight_limit*/)/*sudo_set_max_weight_limit*/;
-    }
-
     #[benchmark]
     fn sudo_set_max_registrations_per_block() {
         // disable admin freeze window

pallets/admin-utils/src/lib.rs

@@ -426,40 +426,6 @@ pub mod pallet {
             Ok(())
         }
 
-        /// The extrinsic sets the adjustment beta for a subnet.
-        /// It is only callable by the root account or subnet owner.
-        /// The extrinsic will call the Subtensor pallet to set the adjustment beta.
-        #[pallet::call_index(12)]
-        #[pallet::weight(Weight::from_parts(26_890_000, 0)
-        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(3_u64))
-        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
-        pub fn sudo_set_max_weight_limit(
-            origin: OriginFor<T>,
-            netuid: NetUid,
-            max_weight_limit: u16,
-        ) -> DispatchResult {
-            let maybe_owner = pallet_subtensor::Pallet::<T>::ensure_sn_owner_or_root_with_limits(
-                origin,
-                netuid,
-                &[Hyperparameter::MaxWeightLimit.into()],
-            )?;
-
-            ensure!(
-                pallet_subtensor::Pallet::<T>::if_subnet_exist(netuid),
-                Error::<T>::SubnetDoesNotExist
-            );
-            pallet_subtensor::Pallet::<T>::set_max_weight_limit(netuid, max_weight_limit);
-            pallet_subtensor::Pallet::<T>::record_owner_rl(
-                maybe_owner,
-                netuid,
-                &[Hyperparameter::MaxWeightLimit.into()],
-            );
-            log::debug!(
-                "MaxWeightLimitSet( netuid: {netuid:?} max_weight_limit: {max_weight_limit:?} ) "
-            );
-            Ok(())
-        }
-
         /// The extrinsic sets the immunity period for a subnet.
         /// It is only callable by the root account or subnet owner.
         /// The extrinsic will call the Subtensor pallet to set the immunity period.

pallets/admin-utils/src/tests/mock.rs

@@ -77,7 +77,6 @@ pub type UncheckedExtrinsic = TestXt<RuntimeCall, ()>;
 parameter_types! {
     pub const InitialMinAllowedWeights: u16 = 0;
     pub const InitialEmissionValue: u16 = 0;
-    pub const InitialMaxWeightsLimit: u16 = u16::MAX;
     pub BlockWeights: limits::BlockWeights = limits::BlockWeights::with_sensible_defaults(
         Weight::from_parts(2_000_000_000_000, u64::MAX),
         Perbill::from_percent(75),
@@ -162,7 +161,6 @@ impl pallet_subtensor::Config for Test {
     type Scheduler = Scheduler;
     type InitialMinAllowedWeights = InitialMinAllowedWeights;
     type InitialEmissionValue = InitialEmissionValue;
-    type InitialMaxWeightsLimit = InitialMaxWeightsLimit;
     type InitialTempo = InitialTempo;
     type InitialDifficulty = InitialDifficulty;
     type InitialAdjustmentInterval = InitialAdjustmentInterval;

pallets/admin-utils/src/tests/mod.rs

@@ -391,39 +391,6 @@ fn test_sudo_subnet_owner_cut() {
     });
 }
 
-#[test]
-fn test_sudo_set_max_weight_limit() {
-    new_test_ext().execute_with(|| {
-        let netuid = NetUid::from(1);
-        let to_be_set: u16 = 10;
-        add_network(netuid, 10);
-        let init_value: u16 = SubtensorModule::get_max_weight_limit(netuid);
-        assert_eq!(
-            AdminUtils::sudo_set_max_weight_limit(
-                <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
-                netuid,
-                to_be_set
-            ),
-            Err(DispatchError::BadOrigin)
-        );
-        assert_eq!(
-            AdminUtils::sudo_set_max_weight_limit(
-                <<Test as Config>::RuntimeOrigin>::root(),
-                netuid.next(),
-                to_be_set
-            ),
-            Err(Error::<Test>::SubnetDoesNotExist.into())
-        );
-        assert_eq!(SubtensorModule::get_max_weight_limit(netuid), init_value);
-        assert_ok!(AdminUtils::sudo_set_max_weight_limit(
-            <<Test as Config>::RuntimeOrigin>::root(),
-            netuid,
-            to_be_set
-        ));
-        assert_eq!(SubtensorModule::get_max_weight_limit(netuid), to_be_set);
-    });
-}
-
 #[test]
 fn test_sudo_set_issuance() {
     new_test_ext().execute_with(|| {

pallets/subtensor/src/coinbase/root.rs

@@ -284,7 +284,6 @@ impl<T: Config> Pallet<T> {
         MaxAllowedUids::<T>::remove(netuid);
         ImmunityPeriod::<T>::remove(netuid);
         ActivityCutoff::<T>::remove(netuid);
-        MaxWeightsLimit::<T>::remove(netuid);
         MinAllowedWeights::<T>::remove(netuid);
         RegistrationsThisInterval::<T>::remove(netuid);
         POWRegistrationsThisInterval::<T>::remove(netuid);

pallets/subtensor/src/lib.rs

@@ -650,11 +650,6 @@ pub mod pallet {
         T::InitialActivityCutoff::get()
     }
     #[pallet::type_value]
-    /// Default maximum weights limit.
-    pub fn DefaultMaxWeightsLimit<T: Config>() -> u16 {
-        T::InitialMaxWeightsLimit::get()
-    }
-    #[pallet::type_value]
     /// Default weights version key.
     pub fn DefaultWeightsVersionKey<T: Config>() -> u64 {
         T::InitialWeightsVersionKey::get()
@@ -1402,6 +1397,11 @@ pub mod pallet {
     /// --- MAP ( netuid ) --> activity_cutoff
     pub type ActivityCutoff<T> =
         StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultActivityCutoff<T>>;
+    #[pallet::type_value]
+    /// Default maximum weights limit.
+    pub fn DefaultMaxWeightsLimit<T: Config>() -> u16 {
+        u16::MAX
+    }
     #[pallet::storage]
     /// --- MAP ( netuid ) --> max_weight_limit
     pub type MaxWeightsLimit<T> =

pallets/subtensor/src/macros/config.rs

@@ -72,9 +72,6 @@ mod config {
         /// Initial Emission Ratio.
         #[pallet::constant]
         type InitialEmissionValue: Get<u16>;
-        /// Initial max weight limit.
-        #[pallet::constant]
-        type InitialMaxWeightsLimit: Get<u16>;
         /// Tempo for each network.
         #[pallet::constant]
         type InitialTempo: Get<u16>;