Merge pull request #1469 from opentensor/fix/min-burn-set-low-on-new-subnet

Fix/min burn set low on new subnet

Author: sam0x17

pallets/subtensor/src/subnets/subnet.rs

@@ -239,7 +239,7 @@ impl<T: Config> Pallet<T> {
             netuid_to_register,
             mechid
         );
-        Self::deposit_event(Event::NetworkAdded(netuid_to_register, 0));
+        Self::deposit_event(Event::NetworkAdded(netuid_to_register, mechid));
 
         // --- 17. Return success.
         Ok(())
@@ -272,7 +272,6 @@ impl<T: Config> Pallet<T> {
         Self::set_target_registrations_per_interval(netuid, 1);
         Self::set_adjustment_alpha(netuid, 17_893_341_751_498_265_066); // 18_446_744_073_709_551_615 * 0.97 = 17_893_341_751_498_265_066
         Self::set_immunity_period(netuid, 5000);
-        Self::set_min_burn(netuid, 1);
         Self::set_min_difficulty(netuid, u64::MAX);
         Self::set_max_difficulty(netuid, u64::MAX);
 

pallets/subtensor/src/tests/mock.rs

@@ -152,7 +152,7 @@ parameter_types! {
     pub const InitialTxDelegateTakeRateLimit: u64 = 1; // 1 block take rate limit for testing
     pub const InitialTxChildKeyTakeRateLimit: u64 = 1; // 1 block take rate limit for testing
     pub const InitialBurn: u64 = 0;
-    pub const InitialMinBurn: u64 = 0;
+    pub const InitialMinBurn: u64 = 500_000;
     pub const InitialMaxBurn: u64 = 1_000_000_000;
     pub const InitialValidatorPruneLen: u64 = 0;
     pub const InitialScalingLawPower: u16 = 50;

pallets/subtensor/src/tests/registration.rs

@@ -1,5 +1,6 @@
 #![allow(clippy::unwrap_used)]
 
+use approx::assert_abs_diff_eq;
 use frame_support::traits::Currency;
 
 use super::mock::*;
@@ -535,11 +536,11 @@ fn test_burn_adjustment() {
     new_test_ext(1).execute_with(|| {
         let netuid: u16 = 1;
         let tempo: u16 = 13;
-        let burn_cost: u64 = 1000;
+        let init_burn_cost: u64 = InitialMinBurn::get() + 10_000;
         let adjustment_interval = 1;
         let target_registrations_per_interval = 1;
         add_network(netuid, tempo, 0);
-        SubtensorModule::set_burn(netuid, burn_cost);
+        SubtensorModule::set_burn(netuid, init_burn_cost);
         SubtensorModule::set_adjustment_interval(netuid, adjustment_interval);
         SubtensorModule::set_adjustment_alpha(netuid, 58000); // Set to old value.
         SubtensorModule::set_target_registrations_per_interval(
@@ -550,7 +551,7 @@ fn test_burn_adjustment() {
         // Register key 1.
         let hotkey_account_id_1 = U256::from(1);
         let coldkey_account_id_1 = U256::from(1);
-        SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id_1, 10000);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id_1, init_burn_cost);
         assert_ok!(SubtensorModule::burned_register(
             <<Test as Config>::RuntimeOrigin>::signed(hotkey_account_id_1),
             netuid,
@@ -560,7 +561,7 @@ fn test_burn_adjustment() {
         // Register key 2.
         let hotkey_account_id_2 = U256::from(2);
         let coldkey_account_id_2 = U256::from(2);
-        SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id_2, 10000);
+        SubtensorModule::add_balance_to_coldkey_account(&coldkey_account_id_2, init_burn_cost);
         assert_ok!(SubtensorModule::burned_register(
             <<Test as Config>::RuntimeOrigin>::signed(hotkey_account_id_2),
             netuid,
@@ -571,8 +572,13 @@ fn test_burn_adjustment() {
         // Step the block and trigger the adjustment.
         step_block(1);
 
-        // Check the adjusted burn.
-        assert_eq!(SubtensorModule::get_burn_as_u64(netuid), 1500);
+        // Check the adjusted burn is above the initial min burn.
+        assert!(SubtensorModule::get_burn_as_u64(netuid) > init_burn_cost);
+        assert_abs_diff_eq!(
+            SubtensorModule::get_burn_as_u64(netuid),
+            init_burn_cost.saturating_mul(3).saturating_div(2), // 1.5x
+            epsilon = 1000
+        );
     });
 }
 

pallets/subtensor/src/tests/subnet.rs

@@ -222,3 +222,40 @@ fn test_do_start_call_ok_with_same_block_number_after_coinbase() {
         }
     });
 }
+
+#[test]
+fn test_register_network_min_burn_at_default() {
+    new_test_ext(1).execute_with(|| {
+        let sn_owner_coldkey = U256::from(0);
+        let sn_owner_hotkey = U256::from(1);
+        let cost = SubtensorModule::get_network_lock_cost();
+
+        // Give coldkey enough for lock
+        SubtensorModule::add_balance_to_coldkey_account(&sn_owner_coldkey, cost + 10_000_000_000);
+
+        // Register network
+        assert_ok!(SubtensorModule::register_network(
+            <<Test as Config>::RuntimeOrigin>::signed(sn_owner_coldkey),
+            sn_owner_hotkey
+        ));
+        // Get last events
+        let events = System::events();
+        let min_burn_event = events
+            .iter()
+            .filter(|event| {
+                matches!(
+                    event.event,
+                    RuntimeEvent::SubtensorModule(Event::<Test>::NetworkAdded(..))
+                )
+            })
+            .last();
+
+        let netuid = match min_burn_event.map(|event| event.event.clone()) {
+            Some(RuntimeEvent::SubtensorModule(Event::<Test>::NetworkAdded(netuid, _))) => netuid,
+            _ => panic!("Expected NetworkAdded event"),
+        };
+
+        // Check min burn is set to default
+        assert_eq!(MinBurn::<Test>::get(netuid), InitialMinBurn::get());
+    });
+}