fix subnet creation logic

Author: unconst

pallets/subtensor/src/migrations/migrate_rao.rs

@@ -6,7 +6,6 @@ use sp_runtime::format;
 use substrate_fixed::types::U64F64;
 
 use super::*;
-use crate::subnets::subnet::POOL_INITIAL_TAO;
 
 pub fn migrate_rao<T: Config>() -> Weight {
     let migration_name = b"migrate_rao".to_vec();
@@ -76,18 +75,26 @@ pub fn migrate_rao<T: Config>() -> Weight {
 
         // Put initial TAO from lock into subnet TAO and produce numerically equal amount of Alpha
         // The initial TAO is the locked amount, with a minimum of 1 RAO and a cap of 100 TAO.
-        let pool_initial_tao = POOL_INITIAL_TAO.min(lock.max(1));
+        let pool_initial_tao = Pallet::<T>::get_network_min_lock();
+        if lock < pool_initial_tao {
+            let difference: u64 = pool_initial_tao.saturating_sub( lock );
+            TotalIssuance::<T>::mutate(|total| {
+                *total = total.saturating_add(difference);
+            });
+        }
 
         let remaining_lock = lock.saturating_sub(pool_initial_tao);
         // Refund the owner for the remaining lock.
         Pallet::<T>::add_balance_to_coldkey_account(&owner, remaining_lock);
-        SubnetTAO::<T>::insert(netuid, pool_initial_tao); // Set TAO to the lock.
-
+        SubnetLocked::<T>::insert( netuid, 0 ); // Clear lock amount.
+        SubnetTAO::<T>::insert( netuid, pool_initial_tao); 
+        TotalStake::<T>::mutate(|total| {
+            *total = total.saturating_add( pool_initial_tao);
+        }); // Increase total stake.
         SubnetAlphaIn::<T>::insert(
             netuid,
-            pool_initial_tao.saturating_mul(netuids.len() as u64),
-        ); // Set AlphaIn to the initial alpha distribution.
-
+            pool_initial_tao
+        ); // Set initial alpha to pool initial tao.
         SubnetAlphaOut::<T>::insert(netuid, 0); // Set zero subnet alpha out.
         SubnetMechanism::<T>::insert(netuid, 1); // Convert to dynamic immediately with initialization.
         Tempo::<T>::insert(netuid, DefaultTempo::<T>::get());

pallets/subtensor/src/subnets/subnet.rs

@@ -2,8 +2,6 @@ use super::*;
 use frame_support::IterableStorageMap;
 use sp_core::Get;
 
-pub(crate) const POOL_INITIAL_TAO: u64 = 100_000_000_000;
-
 impl<T: Config> Pallet<T> {
     /// Retrieves the unique identifier (UID) for the root network.
     ///
@@ -237,16 +235,10 @@ impl<T: Config> Pallet<T> {
 
         // Put initial TAO from lock into subnet TAO and produce numerically equal amount of Alpha
         // The initial TAO is the locked amount, with a minimum of 1 RAO and a cap of 100 TAO.
-        let pool_initial_tao = POOL_INITIAL_TAO.min(actual_tao_lock_amount.max(1));
-
-        let actual_tao_lock_amount_less_pool_tao =
-            actual_tao_lock_amount.saturating_sub(pool_initial_tao);
+        let pool_initial_tao = Self::get_network_min_lock();
+        let actual_tao_lock_amount_less_pool_tao = actual_tao_lock_amount.saturating_sub(pool_initial_tao);
         SubnetTAO::<T>::insert(netuid_to_register, pool_initial_tao);
-        SubnetAlphaIn::<T>::insert(
-            netuid_to_register,
-            pool_initial_tao.saturating_mul(Self::get_all_subnet_netuids().len() as u64),
-        ); // Set AlphaIn to the initial alpha distribution.
-
+        SubnetAlphaIn::<T>::insert( netuid_to_register, pool_initial_tao); 
         SubnetOwner::<T>::insert(netuid_to_register, coldkey.clone());
         SubnetOwnerHotkey::<T>::insert(netuid_to_register, hotkey.clone());
         TotalStakeAtDynamic::<T>::insert(netuid_to_register, TotalStake::<T>::get());

pallets/subtensor/src/tests/migration.rs

@@ -551,7 +551,7 @@ fn test_migrate_commit_reveal_2() {
     });
 }
 
-// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --workspace --test migration -- test_migrate_rao --exact --nocapture
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::migration::test_migrate_rao --exact --show-output --nocapture
 #[test]
 fn test_migrate_rao() {
     new_test_ext(1).execute_with(|| {
@@ -565,6 +565,7 @@ fn test_migrate_rao() {
         let coldkey3 = U256::from(5);
         let stake_amount: u64 = 1_000_000_000;
         let lock_amount: u64 = 500;
+        NetworkMinLockCost::<Test>::set(500);
 
         // Add networks root and alpha
         add_network(netuid_0, 1, 0);
@@ -600,7 +601,7 @@ fn test_migrate_rao() {
         assert_eq!(SubnetTAO::<Test>::get(netuid_0), 4 * stake_amount); // Root has everything
         assert_eq!(SubnetTAO::<Test>::get(netuid_1), lock_amount); // Initial Rao amount.
         assert_eq!(SubnetAlphaIn::<Test>::get(netuid_0), 1); // No Alpha in pool on root.
-        assert_eq!(SubnetAlphaIn::<Test>::get(netuid_1), 2 * lock_amount); // Initial Rao amount == num_subnets * lock_amount
+        assert_eq!(SubnetAlphaIn::<Test>::get(netuid_1), lock_amount); // Initial Rao amount == num_subnets * lock_amount
         assert_eq!(SubnetAlphaOut::<Test>::get(netuid_0), 4 * stake_amount); // All stake is outstanding.
         assert_eq!(SubnetAlphaOut::<Test>::get(netuid_1), 0); // No stake outstanding.
 

pallets/subtensor/src/tests/networks.rs

@@ -282,6 +282,7 @@ fn test_schedule_dissolve_network_execution_with_coldkey_swap() {
     })
 }
 
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::networks::test_register_subnet_low_lock_cost --exact --show-output --nocapture
 #[test]
 fn test_register_subnet_low_lock_cost() {
     new_test_ext(1).execute_with(|| {
@@ -300,32 +301,34 @@ fn test_register_subnet_low_lock_cost() {
         // Ensure that both Subnet TAO and Subnet Alpha In equal to (actual) lock_cost
         assert_eq!(
             SubnetTAO::<Test>::get(netuid),
-            lock_cost - ExistentialDeposit::get(),
+            lock_cost,
         );
         assert_eq!(
             SubnetAlphaIn::<Test>::get(netuid),
-            lock_cost - ExistentialDeposit::get(),
+            lock_cost,
         );
     })
 }
 
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::networks::test_register_subnet_high_lock_cost --exact --show-output --nocapture
 #[test]
 fn test_register_subnet_high_lock_cost() {
     new_test_ext(1).execute_with(|| {
-        NetworkMinLockCost::<Test>::set(1_000_000_000_000);
-        NetworkLastLockCost::<Test>::set(1_000_000_000_000);
+        let lock_cost: u64 = 1_000_000_000_000;
+        NetworkMinLockCost::<Test>::set(lock_cost);
+        NetworkLastLockCost::<Test>::set(lock_cost);
 
         // Make sure lock cost is higher than 100 TAO
         let lock_cost = SubtensorModule::get_network_lock_cost();
-        assert!(lock_cost > 100_000_000_000);
+        assert!(lock_cost >= 1_000_000_000_000);
 
         let subnet_owner_coldkey = U256::from(1);
         let subnet_owner_hotkey = U256::from(2);
         let netuid: u16 = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         assert!(SubtensorModule::if_subnet_exist(netuid));
 
         // Ensure that both Subnet TAO and Subnet Alpha In equal to 100 TAO
-        assert_eq!(SubnetTAO::<Test>::get(netuid), 100_000_000_000,);
-        assert_eq!(SubnetAlphaIn::<Test>::get(netuid), 100_000_000_000,);
+        assert_eq!(SubnetTAO::<Test>::get(netuid), lock_cost);
+        assert_eq!(SubnetAlphaIn::<Test>::get(netuid), lock_cost);
     })
 }

pallets/subtensor/src/utils/try_state.rs

@@ -1,7 +1,6 @@
 use frame_support::traits::fungible::Inspect;
 
 use super::*;
-use crate::subnets::subnet::POOL_INITIAL_TAO;
 
 impl<T: Config> Pallet<T> {
     /// Checks [`TotalIssuance`] equals the sum of currency issuance, total stake, and total subnet
@@ -51,7 +50,7 @@ impl<T: Config> Pallet<T> {
                 // root network doesn't have initial pool TAO
                 acc
             } else {
-                acc.saturating_sub(POOL_INITIAL_TAO)
+                acc.saturating_sub(Self::get_network_min_lock())
             }
         });