Merge pull request #368 from opentensor/chore/merge-sam-devnet-tmp

merge `sam-devnet-tmp` to `main`

Author: orriin

.github/workflows/check-rust.yml

@@ -9,26 +9,12 @@ on:
   ##
   # Run automatically for any push that changes Rust file(s)
   push:
-    branches:
-      - main
-      - $default-branch
-
-    paths:
-      - "**.rs"
-      - "**/Cargo.toml"
-      - "**/Cargo.lock"
+    branches: [main, development, staging]
 
   ##
   # Run automatically for PRs against default/main branch if Rust files change
   pull_request:
-    branches:
-      - main
-      - $default-branch
-
-    paths:
-      - "**.rs"
-      - "**/Cargo.toml"
-      - "**/Cargo.lock"
+    branches: [main, development, staging]
 
   ## Allow running workflow manually from the Actions tab
   workflow_dispatch:

pallets/admin-utils/src/lib.rs

@@ -53,7 +53,6 @@ pub mod pallet {
     }
 
     #[pallet::event]
-    #[pallet::generate_deposit(pub(super) fn deposit_event)]
     pub enum Event<T: Config> {}
 
     // Errors inform users that something went wrong.
@@ -765,6 +764,27 @@ pub mod pallet {
             T::Subtensor::set_weights_min_stake(min_stake);
             Ok(())
         }
+
+        /// Sets the minimum stake required for nominators, and clears small nominations
+        /// that are below the minimum required stake.
+        #[pallet::call_index(43)]
+        #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
+        pub fn sudo_set_nominator_min_required_stake(
+            origin: OriginFor<T>,
+            // The minimum stake required for nominators.
+            min_stake: u64,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+            let prev_min_stake = T::Subtensor::get_nominator_min_required_stake();
+            log::trace!("Setting minimum stake to: {}", min_stake);
+            T::Subtensor::set_nominator_min_required_stake(min_stake);
+            if min_stake > prev_min_stake {
+                log::trace!("Clearing small nominations");
+                T::Subtensor::clear_small_nominations();
+                log::trace!("Small nominations cleared");
+            }
+            Ok(())
+        }
     }
 }
 
@@ -853,4 +873,7 @@ pub trait SubtensorInterface<AccountId, Balance, RuntimeOrigin> {
     fn set_weights_set_rate_limit(netuid: u16, weights_set_rate_limit: u64);
     fn init_new_network(netuid: u16, tempo: u16);
     fn set_weights_min_stake(min_stake: u64);
+    fn get_nominator_min_required_stake() -> u64;
+    fn set_nominator_min_required_stake(min_stake: u64);
+    fn clear_small_nominations();
 }

pallets/admin-utils/tests/mock.rs

@@ -1,5 +1,5 @@
 use frame_support::{
-    parameter_types,
+    assert_ok, parameter_types,
     traits::{Everything, Hooks, StorageMapShim},
     weights,
 };
@@ -110,6 +110,8 @@ parameter_types! {
     pub const InitialNetworkLockReductionInterval: u64 = 2; // 2 blocks.
     pub const InitialSubnetLimit: u16 = 10; // Max 10 subnets.
     pub const InitialNetworkRateLimit: u64 = 0;
+    pub const InitialTargetStakesPerInterval: u16 = 1;
+
 }
 
 impl pallet_subtensor::Config for Test {
@@ -158,6 +160,7 @@ impl pallet_subtensor::Config for Test {
     type InitialNetworkLockReductionInterval = InitialNetworkLockReductionInterval;
     type InitialSubnetLimit = InitialSubnetLimit;
     type InitialNetworkRateLimit = InitialNetworkRateLimit;
+    type InitialTargetStakesPerInterval = InitialTargetStakesPerInterval;
 }
 
 impl system::Config for Test {
@@ -433,6 +436,18 @@ impl pallet_admin_utils::SubtensorInterface<AccountId, Balance, RuntimeOrigin> f
     fn set_weights_min_stake(min_stake: u64) {
         SubtensorModule::set_weights_min_stake(min_stake);
     }
+
+    fn set_nominator_min_required_stake(min_stake: u64) {
+        SubtensorModule::set_nominator_min_required_stake(min_stake);
+    }
+
+    fn get_nominator_min_required_stake() -> u64 {
+        SubtensorModule::get_nominator_min_required_stake()
+    }
+
+    fn clear_small_nominations() {
+        SubtensorModule::clear_small_nominations();
+    }
 }
 
 impl pallet_admin_utils::Config for Test {
@@ -464,3 +479,42 @@ pub(crate) fn run_to_block(n: u64) {
         SubtensorModule::on_initialize(System::block_number());
     }
 }
+
+#[allow(dead_code)]
+pub fn register_ok_neuron(
+    netuid: u16,
+    hotkey_account_id: U256,
+    coldkey_account_id: U256,
+    start_nonce: u64,
+) {
+    let block_number: u64 = SubtensorModule::get_current_block_as_u64();
+    let (nonce, work): (u64, Vec<u8>) = SubtensorModule::create_work_for_block_number(
+        netuid,
+        block_number,
+        start_nonce,
+        &hotkey_account_id,
+    );
+    let result = SubtensorModule::register(
+        <<Test as frame_system::Config>::RuntimeOrigin>::signed(hotkey_account_id),
+        netuid,
+        block_number,
+        nonce,
+        work,
+        hotkey_account_id,
+        coldkey_account_id,
+    );
+    assert_ok!(result);
+    log::info!(
+        "Register ok neuron: netuid: {:?}, coldkey: {:?}, hotkey: {:?}",
+        netuid,
+        hotkey_account_id,
+        coldkey_account_id
+    );
+}
+
+#[allow(dead_code)]
+pub fn add_network(netuid: u16, tempo: u16, _modality: u16) {
+    SubtensorModule::init_new_network(netuid, tempo);
+    SubtensorModule::set_network_registration_allowed(netuid, true);
+    SubtensorModule::set_network_pow_registration_allowed(netuid, true);
+}

pallets/admin-utils/tests/tests.rs

@@ -8,13 +8,6 @@ use sp_core::U256;
 mod mock;
 use mock::*;
 
-#[allow(dead_code)]
-pub fn add_network(netuid: u16, tempo: u16, modality: u16) {
-    SubtensorModule::init_new_network(netuid, tempo);
-    SubtensorModule::set_network_registration_allowed(netuid, true);
-    SubtensorModule::set_network_pow_registration_allowed(netuid, true);
-}
-
 #[test]
 fn test_sudo_set_default_take() {
     new_test_ext().execute_with(|| {
@@ -884,3 +877,189 @@ fn test_sudo_set_network_pow_registration_allowed() {
         );
     });
 }
+
+mod sudo_set_nominator_min_required_stake {
+    use super::*;
+
+    #[test]
+    fn can_only_be_called_by_admin() {
+        new_test_ext().execute_with(|| {
+            let to_be_set: u64 = SubtensorModule::get_nominator_min_required_stake() + 5 as u64;
+            assert_eq!(
+                AdminUtils::sudo_set_nominator_min_required_stake(
+                    <<Test as Config>::RuntimeOrigin>::signed(U256::from(0)),
+                    to_be_set
+                ),
+                Err(DispatchError::BadOrigin.into())
+            );
+        });
+    }
+
+    #[test]
+    fn sets_a_lower_value() {
+        new_test_ext().execute_with(|| {
+            assert_ok!(AdminUtils::sudo_set_nominator_min_required_stake(
+                <<Test as Config>::RuntimeOrigin>::root(),
+                10u64
+            ));
+            assert_eq!(SubtensorModule::get_nominator_min_required_stake(), 10u64);
+
+            assert_ok!(AdminUtils::sudo_set_nominator_min_required_stake(
+                <<Test as Config>::RuntimeOrigin>::root(),
+                5u64
+            ));
+            assert_eq!(SubtensorModule::get_nominator_min_required_stake(), 5u64);
+        });
+    }
+
+    #[test]
+    fn sets_a_higher_value() {
+        new_test_ext().execute_with(|| {
+            let to_be_set: u64 = SubtensorModule::get_nominator_min_required_stake() + 5 as u64;
+            assert_ok!(AdminUtils::sudo_set_nominator_min_required_stake(
+                <<Test as Config>::RuntimeOrigin>::root(),
+                to_be_set
+            ));
+            assert_eq!(
+                SubtensorModule::get_nominator_min_required_stake(),
+                to_be_set
+            );
+        });
+    }
+
+    #[test]
+    fn clears_staker_nominations_below_min() {
+        new_test_ext().execute_with(|| {
+            System::set_block_number(1);
+
+            // Create accounts.
+            let netuid = 1;
+            let hot1 = U256::from(1);
+            let hot2 = U256::from(2);
+            let cold1 = U256::from(3);
+            let cold2 = U256::from(4);
+
+            SubtensorModule::set_target_stakes_per_interval(10);
+            // Register network.
+            add_network(netuid, 0, 0);
+
+            // Register hot1.
+            register_ok_neuron(netuid, hot1, cold1, 0);
+            assert_ok!(SubtensorModule::do_become_delegate(
+                <<Test as Config>::RuntimeOrigin>::signed(cold1),
+                hot1,
+                0
+            ));
+            assert_eq!(SubtensorModule::get_owning_coldkey_for_hotkey(&hot1), cold1);
+
+            // Register hot2.
+            register_ok_neuron(netuid, hot2, cold2, 0);
+            assert_ok!(SubtensorModule::do_become_delegate(
+                <<Test as Config>::RuntimeOrigin>::signed(cold2),
+                hot2,
+                0
+            ));
+            assert_eq!(SubtensorModule::get_owning_coldkey_for_hotkey(&hot2), cold2);
+
+            // Add stake cold1 --> hot1 (non delegation.)
+            SubtensorModule::add_balance_to_coldkey_account(&cold1, 5);
+            assert_ok!(SubtensorModule::add_stake(
+                <<Test as Config>::RuntimeOrigin>::signed(cold1),
+                hot1,
+                1
+            ));
+            assert_eq!(
+                SubtensorModule::get_stake_for_coldkey_and_hotkey(&cold1, &hot1),
+                1
+            );
+            assert_eq!(Balances::free_balance(cold1), 4);
+
+            // Add stake cold2 --> hot1 (is delegation.)
+            SubtensorModule::add_balance_to_coldkey_account(&cold2, 5);
+            assert_ok!(SubtensorModule::add_stake(
+                <<Test as Config>::RuntimeOrigin>::signed(cold2),
+                hot1,
+                1
+            ));
+            assert_eq!(
+                SubtensorModule::get_stake_for_coldkey_and_hotkey(&cold2, &hot1),
+                1
+            );
+            assert_eq!(Balances::free_balance(cold2), 4);
+
+            // Add stake cold1 --> hot2 (non delegation.)
+            SubtensorModule::add_balance_to_coldkey_account(&cold1, 5);
+            assert_ok!(SubtensorModule::add_stake(
+                <<Test as Config>::RuntimeOrigin>::signed(cold1),
+                hot2,
+                1
+            ));
+            assert_eq!(
+                SubtensorModule::get_stake_for_coldkey_and_hotkey(&cold1, &hot2),
+                1
+            );
+            assert_eq!(Balances::free_balance(cold1), 8);
+
+            // Add stake cold2 --> hot2 (is delegation.)
+            SubtensorModule::add_balance_to_coldkey_account(&cold2, 5);
+            assert_ok!(SubtensorModule::add_stake(
+                <<Test as Config>::RuntimeOrigin>::signed(cold2),
+                hot2,
+                1
+            ));
+            assert_eq!(
+                SubtensorModule::get_stake_for_coldkey_and_hotkey(&cold2, &hot2),
+                1
+            );
+            assert_eq!(Balances::free_balance(cold2), 8);
+
+            // Set min stake to 0 (noop)
+            assert_ok!(AdminUtils::sudo_set_nominator_min_required_stake(
+                <<Test as Config>::RuntimeOrigin>::root(),
+                0u64
+            ));
+            assert_eq!(
+                SubtensorModule::get_stake_for_coldkey_and_hotkey(&cold1, &hot1),
+                1
+            );
+            assert_eq!(
+                SubtensorModule::get_stake_for_coldkey_and_hotkey(&cold1, &hot2),
+                1
+            );
+            assert_eq!(
+                SubtensorModule::get_stake_for_coldkey_and_hotkey(&cold2, &hot1),
+                1
+            );
+            assert_eq!(
+                SubtensorModule::get_stake_for_coldkey_and_hotkey(&cold2, &hot2),
+                1
+            );
+
+            // Set min nomination to 10: should clear (cold2, hot1) and (cold1, hot2).
+            assert_ok!(AdminUtils::sudo_set_nominator_min_required_stake(
+                <<Test as Config>::RuntimeOrigin>::root(),
+                10u64
+            ));
+            assert_eq!(
+                SubtensorModule::get_stake_for_coldkey_and_hotkey(&cold1, &hot1),
+                1
+            );
+            assert_eq!(
+                SubtensorModule::get_stake_for_coldkey_and_hotkey(&cold1, &hot2),
+                0
+            );
+            assert_eq!(
+                SubtensorModule::get_stake_for_coldkey_and_hotkey(&cold2, &hot1),
+                0
+            );
+            assert_eq!(
+                SubtensorModule::get_stake_for_coldkey_and_hotkey(&cold2, &hot2),
+                1
+            );
+
+            // Balances have been added back into accounts.
+            assert_eq!(Balances::free_balance(cold1), 9);
+            assert_eq!(Balances::free_balance(cold2), 9);
+        });
+    }
+}