Merge branch 'devnet-ready' into fix-ts-tests-ci

# Conflicts:
#	ts-tests/scripts/generate-types.sh

Author: evgeny-s

.github/workflows/typescript-e2e.yml

@@ -103,6 +103,8 @@ jobs:
             binary: release
           - test: zombienet_staking
             binary: fast
+          - test: zombienet_coldkey_swap
+            binary: fast
 
     name: "typescript-e2e-${{ matrix.test }}"
 

Cargo.lock

@@ -7,6 +7,7 @@
 use core::num::NonZeroU64;
 
 use frame_support::dispatch::DispatchResult;
+use frame_support::pallet_prelude::Zero;
 use frame_support::traits::{Contains, Everything, InherentBuilder, InsideBoth};
 use frame_support::weights::Weight;
 use frame_support::weights::constants::RocksDbWeight;
@@ -25,7 +26,9 @@ use sp_runtime::{
     traits::{BlakeTwo256, Convert, IdentityLookup},
 };
 use sp_std::{cell::RefCell, cmp::Ordering, sync::OnceLock};
-use subtensor_runtime_common::{AlphaBalance, AuthorshipInfo, NetUid, TaoBalance};
+use subtensor_runtime_common::{
+    AlphaBalance, AuthorshipInfo, NetUid, Saturating, TaoBalance, Token,
+};
 
 type Block = frame_system::mocking::MockBlock<Test>;
 
@@ -654,27 +657,69 @@ pub fn register_ok_neuron(
     netuid: NetUid,
     hotkey_account_id: U256,
     coldkey_account_id: U256,
-    start_nonce: u64,
+    _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);
+    // Ensure reserves exist for swap/burn path, but do NOT clobber reserves if the test already set them.
+    let reserve: u64 = 1_000_000_000_000;
+    let tao_reserve = SubnetTAO::<Test>::get(netuid);
+    let alpha_reserve = SubnetAlphaIn::<Test>::get(netuid)
+        .saturating_add(SubnetAlphaInProvided::<Test>::get(netuid));
+
+    if tao_reserve.is_zero() && alpha_reserve.is_zero() {
+        setup_reserves(netuid, reserve.into(), reserve.into());
+    }
+
+    // Ensure coldkey has enough to pay the current burn AND is not fully drained to zero.
+    // This avoids ZeroBalanceAfterWithdrawn in burned_register.
+    let top_up_for_burn = |netuid: NetUid, cold: U256| {
+        let burn: TaoBalance = SubtensorModule::get_burn(netuid);
+
+        // Make sure something remains after withdrawal even if ED is 0 in tests.
+        let ed: TaoBalance = ExistentialDeposit::get();
+        let min_remaining: TaoBalance = ed.max(1.into());
+
+        // Small buffer for safety (fees / rounding / future changes).
+        let buffer: TaoBalance = 10.into();
+
+        let min_balance_needed: TaoBalance =
+            burn.saturating_add(min_remaining).saturating_add(buffer);
+
+        let bal: TaoBalance = SubtensorModule::get_coldkey_balance(&cold);
+        if bal < min_balance_needed {
+            SubtensorModule::add_balance_to_coldkey_account(&cold, min_balance_needed - bal);
+        }
+    };
+
+    top_up_for_burn(netuid, coldkey_account_id);
+
+    let origin = <<Test as frame_system::Config>::RuntimeOrigin>::signed(coldkey_account_id);
+    let result = SubtensorModule::burned_register(origin.clone(), netuid, hotkey_account_id);
+
+    match result {
+        Ok(()) => {
+            // success
+        }
+        Err(e)
+            if e == Error::<Test>::TooManyRegistrationsThisInterval.into()
+                || e == Error::<Test>::NotEnoughBalanceToStake.into()
+                || e == Error::<Test>::ZeroBalanceAfterWithdrawn.into() =>
+        {
+            // Re-top-up and retry once (burn can be state-dependent).
+            top_up_for_burn(netuid, coldkey_account_id);
+
+            assert_ok!(SubtensorModule::burned_register(
+                origin,
+                netuid,
+                hotkey_account_id
+            ));
+        }
+        Err(e) => {
+            panic!("Expected Ok(_). Got Err({e:?})");
+        }
+    }
+
     log::info!(
-        "Register ok neuron: netuid: {netuid:?}, coldkey: {hotkey_account_id:?}, hotkey: {coldkey_account_id:?}"
+        "Register ok neuron: netuid: {netuid:?}, coldkey: {coldkey_account_id:?}, hotkey: {hotkey_account_id:?}"
     );
 }
 

Cargo.toml

@@ -19,17 +19,17 @@ useless_conversion = "allow"
 
 [dependencies]
 pallet-subtensor = { path = "../pallets/subtensor", default-features = false, features = ["std"] }
-frame-support = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "285b4f8b392c517e50e237e717d28ea4f3666e7c", default-features = false, features = ["std"] }
-frame-system = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "285b4f8b392c517e50e237e717d28ea4f3666e7c", default-features = false, features = ["std"] }
-sp-core = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "285b4f8b392c517e50e237e717d28ea4f3666e7c", default-features = false, features = ["std"] }
-sp-io = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "285b4f8b392c517e50e237e717d28ea4f3666e7c", default-features = false, features = ["std"] }
-sp-runtime = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "285b4f8b392c517e50e237e717d28ea4f3666e7c", default-features = false, features = ["std"] }
-sp-std = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "285b4f8b392c517e50e237e717d28ea4f3666e7c", default-features = false, features = ["std"] }
+frame-support = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "7cc54bf2d50ae3921d718736dfeb0de9468539c7", default-features = false, features = ["std"] }
+frame-system = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "7cc54bf2d50ae3921d718736dfeb0de9468539c7", default-features = false, features = ["std"] }
+sp-core = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "7cc54bf2d50ae3921d718736dfeb0de9468539c7", default-features = false, features = ["std"] }
+sp-io = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "7cc54bf2d50ae3921d718736dfeb0de9468539c7", default-features = false, features = ["std"] }
+sp-runtime = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "7cc54bf2d50ae3921d718736dfeb0de9468539c7", default-features = false, features = ["std"] }
+sp-std = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "7cc54bf2d50ae3921d718736dfeb0de9468539c7", default-features = false, features = ["std"] }
 codec = { package = "parity-scale-codec", version = "3.7.5", default-features = false, features = ["derive", "std"] }
 scale-info = { version = "2.11.2", default-features = false, features = ["derive", "std"] }
-pallet-balances = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "285b4f8b392c517e50e237e717d28ea4f3666e7c", default-features = false, features = ["std"] }
-pallet-scheduler = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "285b4f8b392c517e50e237e717d28ea4f3666e7c", default-features = false, features = ["std"] }
-pallet-preimage = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "285b4f8b392c517e50e237e717d28ea4f3666e7c", default-features = false, features = ["std"] }
+pallet-balances = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "7cc54bf2d50ae3921d718736dfeb0de9468539c7", default-features = false, features = ["std"] }
+pallet-scheduler = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "7cc54bf2d50ae3921d718736dfeb0de9468539c7", default-features = false, features = ["std"] }
+pallet-preimage = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "7cc54bf2d50ae3921d718736dfeb0de9468539c7", default-features = false, features = ["std"] }
 pallet-drand = { path = "../pallets/drand", default-features = false, features = ["std"] }
 pallet-subtensor-swap = { path = "../pallets/swap", default-features = false, features = ["std"] }
 pallet-crowdloan = { path = "../pallets/crowdloan", default-features = false, features = ["std"] }
@@ -42,7 +42,7 @@ share-pool = { path = "../primitives/share-pool", default-features = false, feat
 safe-math = { path = "../primitives/safe-math", default-features = false, features = ["std"] }
 log = { version = "0.4.21", default-features = false, features = ["std"] }
 approx = "0.5"
-sp-tracing = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "285b4f8b392c517e50e237e717d28ea4f3666e7c", default-features = false, features = ["std"] }
+sp-tracing = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "7cc54bf2d50ae3921d718736dfeb0de9468539c7", default-features = false, features = ["std"] }
 tracing = "0.1"
 tracing-log = "0.2"
 tracing-subscriber = { version = "=0.3.18", features = ["fmt", "env-filter"] }

chain-extensions/src/mock.rs

@@ -90,6 +90,20 @@ pub mod pallet {
             /// Indicates if the Bonds Reset was enabled or disabled.
             enabled: bool,
         },
+        /// Event emitted when the burn half-life parameter is set for a subnet.
+        BurnHalfLifeSet {
+            /// The network identifier.
+            netuid: NetUid,
+            /// The new burn half-life value.
+            burn_half_life: u16,
+        },
+        /// Event emitted when the burn increase multiplier is set for a subnet.
+        BurnIncreaseMultSet {
+            /// The network identifier.
+            netuid: NetUid,
+            /// The new burn increase multiplier.
+            burn_increase_mult: U64F64,
+        },
     }
 
     // Errors inform users that something went wrong.
@@ -117,6 +131,10 @@ pub mod pallet {
         MaxAllowedUidsGreaterThanDefaultMaxAllowedUids,
         /// Bad parameter value
         InvalidValue,
+        /// Operation is not permitted on the root network.
+        NotPermittedOnRootSubnet,
+        /// POW Registration has been deprecated
+        POWRegistrationDisabled,
     }
     /// Enum for specifying the type of precompile operation.
     #[derive(
@@ -674,30 +692,11 @@ pub mod pallet {
 				.saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1))
 		)]
         pub fn sudo_set_network_pow_registration_allowed(
-            origin: OriginFor<T>,
-            netuid: NetUid,
-            registration_allowed: bool,
+            _origin: OriginFor<T>,
+            _netuid: NetUid,
+            _registration_allowed: bool,
         ) -> DispatchResult {
-            let maybe_owner = pallet_subtensor::Pallet::<T>::ensure_sn_owner_or_root_with_limits(
-                origin,
-                netuid,
-                &[Hyperparameter::PowRegistrationAllowed.into()],
-            )?;
-            pallet_subtensor::Pallet::<T>::ensure_admin_window_open(netuid)?;
-
-            pallet_subtensor::Pallet::<T>::set_network_pow_registration_allowed(
-                netuid,
-                registration_allowed,
-            );
-            log::debug!(
-                "NetworkPowRegistrationAllowed( registration_allowed: {registration_allowed:?} ) "
-            );
-            pallet_subtensor::Pallet::<T>::record_owner_rl(
-                maybe_owner,
-                netuid,
-                &[Hyperparameter::PowRegistrationAllowed.into()],
-            );
-            Ok(())
+            Err(Error::<T>::POWRegistrationDisabled.into())
         }
 
         /// The extrinsic sets the target registrations per interval for a subnet.
@@ -2134,6 +2133,104 @@ pub mod pallet {
             log::trace!("ColdkeySwapReannouncementDelaySet( duration: {duration:?} )");
             Ok(())
         }
+
+        /// Set BurnHalfLife for a subnet.
+        /// It is only callable by root and subnet owner.
+        #[pallet::call_index(89)]
+        #[pallet::weight((
+            Weight::from_parts(25_000_000, 0)
+                .saturating_add(T::DbWeight::get().reads(4))
+                .saturating_add(T::DbWeight::get().writes(1)),
+            DispatchClass::Operational,
+            Pays::Yes,
+        ))]
+        pub fn sudo_set_burn_half_life(
+            origin: OriginFor<T>,
+            netuid: NetUid,
+            burn_half_life: u16,
+        ) -> DispatchResult {
+            let maybe_owner = pallet_subtensor::Pallet::<T>::ensure_sn_owner_or_root_with_limits(
+                origin,
+                netuid,
+                &[Hyperparameter::BurnHalfLife.into()],
+            )?;
+            pallet_subtensor::Pallet::<T>::ensure_admin_window_open(netuid)?;
+
+            ensure!(
+                pallet_subtensor::Pallet::<T>::if_subnet_exist(netuid),
+                Error::<T>::SubnetDoesNotExist
+            );
+            ensure!(!netuid.is_root(), Error::<T>::NotPermittedOnRootSubnet);
+            ensure!(
+                burn_half_life > 0
+                    && burn_half_life <= pallet_subtensor::MaxBurnHalfLife::<T>::get(),
+                Error::<T>::InvalidValue
+            );
+
+            pallet_subtensor::BurnHalfLife::<T>::insert(netuid, burn_half_life);
+            Self::deposit_event(Event::BurnHalfLifeSet {
+                netuid,
+                burn_half_life,
+            });
+
+            pallet_subtensor::Pallet::<T>::record_owner_rl(
+                maybe_owner,
+                netuid,
+                &[Hyperparameter::BurnHalfLife.into()],
+            );
+
+            Ok(())
+        }
+
+        /// Set BurnIncreaseMult for a subnet.
+        /// It is only callable by root and subnet owner.
+        #[pallet::call_index(90)]
+        #[pallet::weight((
+            Weight::from_parts(25_000_000, 0)
+                .saturating_add(T::DbWeight::get().reads(4))
+                .saturating_add(T::DbWeight::get().writes(1)),
+            DispatchClass::Operational,
+            Pays::Yes,
+        ))]
+        pub fn sudo_set_burn_increase_mult(
+            origin: OriginFor<T>,
+            netuid: NetUid,
+            burn_increase_mult: U64F64,
+        ) -> DispatchResult {
+            let maybe_owner = pallet_subtensor::Pallet::<T>::ensure_sn_owner_or_root_with_limits(
+                origin,
+                netuid,
+                &[Hyperparameter::BurnIncreaseMult.into()],
+            )?;
+            pallet_subtensor::Pallet::<T>::ensure_admin_window_open(netuid)?;
+
+            ensure!(
+                pallet_subtensor::Pallet::<T>::if_subnet_exist(netuid),
+                Error::<T>::SubnetDoesNotExist
+            );
+            ensure!(!netuid.is_root(), Error::<T>::NotPermittedOnRootSubnet);
+            ensure!(
+                (1..=3).contains(&burn_increase_mult),
+                Error::<T>::InvalidValue
+            );
+
+            pallet_subtensor::BurnIncreaseMult::<T>::insert(
+                netuid,
+                U64F64::from_num(burn_increase_mult),
+            );
+            Self::deposit_event(Event::BurnIncreaseMultSet {
+                netuid,
+                burn_increase_mult,
+            });
+
+            pallet_subtensor::Pallet::<T>::record_owner_rl(
+                maybe_owner,
+                netuid,
+                &[Hyperparameter::BurnIncreaseMult.into()],
+            );
+
+            Ok(())
+        }
     }
 }