Merge branch 'devnet-ready' into feat/global-subsidies

Author: gztensor

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.
@@ -1252,7 +1218,7 @@ pub mod pallet {
         /// The extrinsic will call the Subtensor pallet to set the minimum delegate take.
         #[pallet::call_index(46)]
         #[pallet::weight((
-            Weight::from_parts(5_000_000, 0).saturating_add(T::DbWeight::get().writes(1_u64)),
+            Weight::from_parts(7_885_000, 0).saturating_add(T::DbWeight::get().writes(1_u64)),
             DispatchClass::Operational,
             Pays::Yes
         ))]
@@ -1999,7 +1965,7 @@ pub mod pallet {
         /// Only callable by root.
         #[pallet::call_index(74)]
         #[pallet::weight((
-			Weight::from_parts(5_771_000, 0)
+			Weight::from_parts(9_418_000, 0)
 				.saturating_add(<T as frame_system::Config>::DbWeight::get().reads(0_u64))
 				.saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)),
 			DispatchClass::Operational

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/crowdloan/src/lib.rs

@@ -638,13 +638,16 @@ pub mod pallet {
             origin: OriginFor<T>,
             #[pallet::compact] crowdloan_id: CrowdloanId,
         ) -> DispatchResultWithPostInfo {
-            ensure_signed(origin)?;
+            let who = ensure_signed(origin)?;
 
             let mut crowdloan = Self::ensure_crowdloan_exists(crowdloan_id)?;
 
             // Ensure the crowdloan is not finalized
             ensure!(!crowdloan.finalized, Error::<T>::AlreadyFinalized);
 
+            // Only the creator can refund the crowdloan
+            ensure!(who == crowdloan.creator, Error::<T>::InvalidOrigin);
+
             let mut refunded_contributors: Vec<T::AccountId> = vec![];
             let mut refund_count = 0;
 

pallets/crowdloan/src/tests.rs

@@ -1618,20 +1618,47 @@ fn test_refund_succeeds() {
 }
 
 #[test]
-fn test_refund_fails_if_bad_origin() {
-    TestState::default().build_and_execute(|| {
-        let crowdloan_id: CrowdloanId = 0;
+fn test_refund_fails_if_bad_or_invalid_origin() {
+    TestState::default()
+        .with_balance(U256::from(1), 100)
+        .build_and_execute(|| {
+            // create a crowdloan
+            let crowdloan_id: CrowdloanId = 0;
+            let creator: AccountOf<Test> = U256::from(1);
+            let initial_deposit: BalanceOf<Test> = 50;
+            let min_contribution: BalanceOf<Test> = 10;
+            let cap: BalanceOf<Test> = 300;
+            let end: BlockNumberFor<Test> = 50;
+            assert_ok!(Crowdloan::create(
+                RuntimeOrigin::signed(creator),
+                initial_deposit,
+                min_contribution,
+                cap,
+                end,
+                Some(noop_call()),
+                None,
+            ));
 
-        assert_err!(
-            Crowdloan::refund(RuntimeOrigin::none(), crowdloan_id),
-            DispatchError::BadOrigin
-        );
+            assert_err!(
+                Crowdloan::refund(RuntimeOrigin::none(), crowdloan_id),
+                DispatchError::BadOrigin
+            );
 
-        assert_err!(
-            Crowdloan::refund(RuntimeOrigin::root(), crowdloan_id),
-            DispatchError::BadOrigin
-        );
-    });
+            assert_err!(
+                Crowdloan::refund(RuntimeOrigin::root(), crowdloan_id),
+                DispatchError::BadOrigin
+            );
+
+            // run some blocks
+            run_to_block(60);
+
+            // try to refund
+            let unknown_contributor: AccountOf<Test> = U256::from(2);
+            assert_err!(
+                Crowdloan::refund(RuntimeOrigin::signed(unknown_contributor), crowdloan_id),
+                pallet_crowdloan::Error::<Test>::InvalidOrigin,
+            );
+        });
 }
 
 #[test]

pallets/subtensor/src/coinbase/mod.rs

@@ -4,3 +4,4 @@ pub mod block_step;
 pub mod reveal_commits;
 pub mod root;
 pub mod run_coinbase;
+pub mod subnet_emissions;