fix: apply lock cost multiplier after subnet registration

- treat missing last_lock_block as post-registration when last_lock > min_lock
- add regression test for lock cost multiplier

Author: GlobalStar117

pallets/subtensor/src/coinbase/root.rs

@@ -511,7 +511,12 @@ impl<T: Config> Pallet<T> {
         let last_lock_block = Self::get_network_last_lock_block();
         let current_block = Self::get_current_block_as_u64();
         let lock_reduction_interval = Self::get_lock_reduction_interval();
-        let mult: TaoCurrency = if last_lock_block == 0 { 1 } else { 2 }.into();
+        let mult: TaoCurrency = if last_lock_block == 0 && last_lock <= min_lock {
+            1
+        } else {
+            2
+        }
+        .into();
 
         let mut lock_cost = last_lock.saturating_mul(mult).saturating_sub(
             last_lock

pallets/subtensor/src/tests/networks.rs

@@ -5,6 +5,7 @@ use crate::migrations::migrate_network_immunity_period;
 use crate::*;
 use frame_support::{assert_err, assert_ok};
 use frame_system::Config;
+use safe_math::SafeDiv;
 use sp_core::U256;
 use sp_std::collections::{btree_map::BTreeMap, vec_deque::VecDeque};
 use substrate_fixed::types::{I96F32, U64F64, U96F32};
@@ -1757,6 +1758,32 @@ fn test_register_subnet_high_lock_cost() {
     })
 }
 
+#[test]
+fn test_lock_cost_uses_multiplier_when_last_lock_block_missing() {
+    new_test_ext(1).execute_with(|| {
+        let min_lock = TaoCurrency::from(1_000);
+        let last_lock = TaoCurrency::from(10_000);
+
+        NetworkMinLockCost::<Test>::set(min_lock);
+        NetworkLastLockCost::<Test>::set(last_lock);
+        SubtensorModule::set_network_last_lock_block(0);
+
+        step_block(1);
+
+        let current_block = SubtensorModule::get_current_block_as_u64();
+        let lock_reduction_interval = SubtensorModule::get_lock_reduction_interval();
+        let per_block_decrement = last_lock
+            .to_u64()
+            .safe_div(lock_reduction_interval)
+            .saturating_mul(current_block.saturating_sub(0));
+        let expected = last_lock
+            .saturating_mul(2u64.into())
+            .saturating_sub(per_block_decrement.into());
+
+        assert_eq!(SubtensorModule::get_network_lock_cost(), expected);
+    })
+}
+
 #[test]
 fn test_tempo_greater_than_weight_set_rate_limit() {
     new_test_ext(1).execute_with(|| {