Merge branch 'devnet-ready' into change-subnet-owner-extrinsics

Author: shamil-gadelshin

evm-tests/src/contracts/alpha.ts

@@ -315,5 +315,18 @@ export const IAlphaABI = [
     ],
     "stateMutability": "view",
     "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "getCKBurn",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
   }
 ]

evm-tests/test/alpha.precompile.test.ts

@@ -8,6 +8,7 @@ import { PublicClient } from "viem";
 import { PolkadotSigner, TypedApi } from "polkadot-api";
 import { toViemAddress, convertPublicKeyToSs58 } from "../src/address-utils"
 import { IAlphaABI, IALPHA_ADDRESS } from "../src/contracts/alpha"
+import { u64 } from "@polkadot-api/substrate-bindings";
 
 describe("Test Alpha Precompile", () => {
     // init substrate part
@@ -209,6 +210,24 @@ describe("Test Alpha Precompile", () => {
             assert.ok(typeof alphaIssuance === 'bigint', "Alpha issuance should be a bigint");
             assert.ok(alphaIssuance >= BigInt(0), "Alpha issuance should be non-negative");
         });
+
+        it("getCKBurn returns valid CK burn rate", async () => {
+            const ckBurn = await publicClient.readContract({
+                abi: IAlphaABI,
+                address: toViemAddress(IALPHA_ADDRESS),
+                functionName: "getCKBurn",
+                args: []
+            })
+
+            const ckBurnOnChain = await api.query.SubtensorModule.CKBurn.getValue()
+
+            assert.strictEqual(ckBurn, ckBurnOnChain, "CK burn should match on chain");
+            assert.ok(ckBurn !== undefined, "CK burn should be defined");
+            const ckBurnPercentage = BigInt(ckBurn) * BigInt(100) / BigInt(2 ** 64 - 1)
+            assert.ok(ckBurnPercentage >= BigInt(0), "CK burn percentage should be non-negative");
+            assert.ok(ckBurnPercentage <= BigInt(100), "CK burn percentage should be less than or equal to 100");
+            assert.ok(typeof ckBurn === 'bigint', "CK burn should be a bigint");
+        });
     });
 
     describe("Global Functions", () => {

pallets/admin-utils/src/lib.rs

@@ -1605,6 +1605,20 @@ pub mod pallet {
             pallet_subtensor::Pallet::<T>::set_owner_immune_neuron_limit(netuid, immune_neurons)?;
             Ok(())
         }
+
+        /// Sets the childkey burn for a subnet.
+        /// It is only callable by the root account.
+        /// The extrinsic will call the Subtensor pallet to set the childkey burn.
+        #[pallet::call_index(73)]
+        #[pallet::weight(Weight::from_parts(15_650_000, 0)
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
+        pub fn sudo_set_ck_burn(origin: OriginFor<T>, burn: u64) -> DispatchResult {
+            ensure_root(origin)?;
+            pallet_subtensor::Pallet::<T>::set_ck_burn(burn);
+            log::debug!("CKBurnSet( burn: {burn:?} ) ");
+            Ok(())
+        }
     }
 }
 

pallets/subtensor/src/coinbase/root.rs

@@ -565,10 +565,10 @@ impl<T: Config> Pallet<T> {
         NetworkLastLockCost::<T>::get()
     }
     pub fn get_network_last_lock_block() -> u64 {
-        NetworkLastRegistered::<T>::get()
+        Self::get_rate_limited_last_block(&RateLimitKey::NetworkLastRegistered)
     }
     pub fn set_network_last_lock_block(block: u64) {
-        NetworkLastRegistered::<T>::set(block);
+        Self::set_rate_limited_last_block(&RateLimitKey::NetworkLastRegistered, block);
     }
     pub fn set_lock_reduction_interval(interval: u64) {
         NetworkLockReductionInterval::<T>::set(interval);
@@ -588,10 +588,13 @@ impl<T: Config> Pallet<T> {
         let halved_interval: I64F64 = interval.saturating_mul(halving);
         halved_interval.saturating_to_num::<u64>()
     }
-    pub fn get_rate_limited_last_block(rate_limit_key: &RateLimitKey) -> u64 {
+    pub fn get_rate_limited_last_block(rate_limit_key: &RateLimitKey<T::AccountId>) -> u64 {
         LastRateLimitedBlock::<T>::get(rate_limit_key)
     }
-    pub fn set_rate_limited_last_block(rate_limit_key: &RateLimitKey, block: u64) {
-        LastRateLimitedBlock::<T>::set(rate_limit_key, block);
+    pub fn set_rate_limited_last_block(rate_limit_key: &RateLimitKey<T::AccountId>, block: u64) {
+        LastRateLimitedBlock::<T>::insert(rate_limit_key, block);
+    }
+    pub fn remove_rate_limited_last_block(rate_limit_key: &RateLimitKey<T::AccountId>) {
+        LastRateLimitedBlock::<T>::remove(rate_limit_key);
     }
 }

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -744,18 +744,19 @@ impl<T: Config> Pallet<T> {
         // Calculate the hotkey's share of the validator emission based on its childkey take
         let validating_emission: U96F32 = U96F32::saturating_from_num(dividends);
         let mut remaining_emission: U96F32 = validating_emission;
-        let childkey_take_proportion: U96F32 =
+        let burn_take_proportion: U96F32 = Self::get_ck_burn();
+        let child_take_proportion: U96F32 =
             U96F32::saturating_from_num(Self::get_childkey_take(hotkey, netuid))
                 .safe_div(U96F32::saturating_from_num(u16::MAX));
-        log::debug!("Childkey take proportion: {childkey_take_proportion:?} for hotkey {hotkey:?}");
+        log::debug!("Childkey take proportion: {child_take_proportion:?} for hotkey {hotkey:?}");
         // NOTE: Only the validation emission should be split amongst parents.
 
         // Grab the owner of the childkey.
         let childkey_owner = Self::get_owning_coldkey_for_hotkey(hotkey);
 
         // Initialize variables to track emission distribution
         let mut to_parents: u64 = 0;
-        let mut total_child_emission_take: U96F32 = U96F32::saturating_from_num(0);
+        let mut total_child_take: U96F32 = U96F32::saturating_from_num(0);
 
         // Initialize variables to calculate total stakes from parents
         let mut total_contribution: U96F32 = U96F32::saturating_from_num(0);
@@ -819,23 +820,26 @@ impl<T: Config> Pallet<T> {
             remaining_emission = remaining_emission.saturating_sub(parent_emission);
 
             // Get the childkey take for this parent.
-            let child_emission_take: U96F32 = if parent_owner == childkey_owner {
-                // The parent is from the same coldkey, so we don't remove any childkey take.
-                U96F32::saturating_from_num(0)
-            } else {
-                childkey_take_proportion
-                    .saturating_mul(U96F32::saturating_from_num(parent_emission))
+            let mut burn_take: U96F32 = U96F32::saturating_from_num(0);
+            let mut child_take: U96F32 = U96F32::saturating_from_num(0);
+            if parent_owner != childkey_owner {
+                // The parent is from a different coldkey, we burn some proportion
+                burn_take = burn_take_proportion.saturating_mul(parent_emission);
+                child_take = child_take_proportion.saturating_mul(parent_emission);
+                parent_emission = parent_emission.saturating_sub(burn_take);
+                parent_emission = parent_emission.saturating_sub(child_take);
+                total_child_take = total_child_take.saturating_add(child_take);
+
+                Self::burn_subnet_alpha(
+                    netuid,
+                    AlphaCurrency::from(burn_take.saturating_to_num::<u64>()),
+                );
             };
+            log::debug!("burn_takee: {burn_take:?} for hotkey {hotkey:?}");
+            log::debug!("child_take: {child_take:?} for hotkey {hotkey:?}");
+            log::debug!("parent_emission: {parent_emission:?} for hotkey {hotkey:?}");
+            log::debug!("total_child_take: {total_child_take:?} for hotkey {hotkey:?}");
 
-            // Remove the childkey take from the parent's emission.
-            parent_emission = parent_emission.saturating_sub(child_emission_take);
-
-            // Add the childkey take to the total childkey take tracker.
-            total_child_emission_take =
-                total_child_emission_take.saturating_add(child_emission_take);
-
-            log::debug!("Child emission take: {child_emission_take:?} for hotkey {hotkey:?}");
-            log::debug!("Parent emission: {parent_emission:?} for hotkey {hotkey:?}");
             log::debug!("remaining emission: {remaining_emission:?}");
 
             // Add the parent's emission to the distribution list
@@ -853,7 +857,7 @@ impl<T: Config> Pallet<T> {
         // Calculate the final emission for the hotkey itself.
         // This includes the take left from the parents and the self contribution.
         let child_emission = remaining_emission
-            .saturating_add(total_child_emission_take)
+            .saturating_add(total_child_take)
             .saturating_to_num::<u64>()
             .into();
 

pallets/subtensor/src/lib.rs

@@ -54,6 +54,7 @@ extern crate alloc;
 
 pub const MAX_CRV3_COMMIT_SIZE_BYTES: u32 = 5000;
 
+#[allow(deprecated)]
 #[deny(missing_docs)]
 #[import_section(errors::errors)]
 #[import_section(events::events)]
@@ -525,11 +526,6 @@ pub mod pallet {
         T::InitialNetworkImmunityPeriod::get()
     }
     #[pallet::type_value]
-    /// Default value for network last registered.
-    pub fn DefaultNetworkLastRegistered<T: Config>() -> u64 {
-        0
-    }
-    #[pallet::type_value]
     /// Default value for network min allowed UIDs.
     pub fn DefaultNetworkMinAllowedUids<T: Config>() -> u16 {
         T::InitialNetworkMinAllowedUids::get()
@@ -867,6 +863,12 @@ pub mod pallet {
         50400
     }
 
+    #[pallet::type_value]
+    /// Default value for ck burn, 18%.
+    pub fn DefaultCKBurn<T: Config>() -> u64 {
+        u64::MAX / 100 * 18
+    }
+
     #[pallet::storage]
     pub type MinActivityCutoff<T: Config> =
         StorageValue<_, u16, ValueQuery, DefaultMinActivityCutoff<T>>;
@@ -920,6 +922,9 @@ pub mod pallet {
     /// --- ITEM --> Global weight
     pub type TaoWeight<T> = StorageValue<_, u64, ValueQuery, DefaultTaoWeight<T>>;
     #[pallet::storage]
+    /// --- ITEM --> CK burn
+    pub type CKBurn<T> = StorageValue<_, u64, ValueQuery, DefaultCKBurn<T>>;
+    #[pallet::storage]
     /// --- ITEM ( default_delegate_take )
     pub type MaxDelegateTake<T> = StorageValue<_, u16, ValueQuery, DefaultDelegateTake<T>>;
     #[pallet::storage]
@@ -1164,10 +1169,6 @@ pub mod pallet {
     pub type NetworkImmunityPeriod<T> =
         StorageValue<_, u64, ValueQuery, DefaultNetworkImmunityPeriod<T>>;
     #[pallet::storage]
-    /// ITEM( network_last_registered_block )
-    pub type NetworkLastRegistered<T> =
-        StorageValue<_, u64, ValueQuery, DefaultNetworkLastRegistered<T>>;
-    #[pallet::storage]
     /// ITEM( min_network_lock_cost )
     pub type NetworkMinLockCost<T> =
         StorageValue<_, TaoCurrency, ValueQuery, DefaultNetworkMinLockCost<T>>;
@@ -1200,7 +1201,7 @@ pub mod pallet {
     #[pallet::storage]
     /// --- MAP ( RateLimitKey ) --> Block number in which the last rate limited operation occured
     pub type LastRateLimitedBlock<T: Config> =
-        StorageMap<_, Identity, RateLimitKey, u64, ValueQuery, DefaultZeroU64<T>>;
+        StorageMap<_, Identity, RateLimitKey<T::AccountId>, u64, ValueQuery, DefaultZeroU64<T>>;
 
     /// ============================
     /// ==== Subnet Locks =====
@@ -1657,14 +1658,17 @@ pub mod pallet {
         u64,
         ValueQuery,
     >;
+    #[deprecated]
     #[pallet::storage]
     /// --- MAP ( key ) --> last_block
     pub type LastTxBlock<T: Config> =
         StorageMap<_, Identity, T::AccountId, u64, ValueQuery, DefaultLastTxBlock<T>>;
+    #[deprecated]
     #[pallet::storage]
     /// --- MAP ( key ) --> last_tx_block_childkey_take
     pub type LastTxBlockChildKeyTake<T: Config> =
         StorageMap<_, Identity, T::AccountId, u64, ValueQuery, DefaultLastTxBlock<T>>;
+    #[deprecated]
     #[pallet::storage]
     /// --- MAP ( key ) --> last_tx_block_delegate_take
     pub type LastTxBlockDelegateTake<T: Config> =
@@ -2135,9 +2139,17 @@ impl<T: Config + pallet_balances::Config<Balance = u64>>
 /// Enum that defines types of rate limited operations for
 /// storing last block when this operation occured
 #[derive(Encode, Decode, Clone, PartialEq, Eq, Debug, TypeInfo)]
-pub enum RateLimitKey {
+pub enum RateLimitKey<AccountId> {
     // The setting sn owner hotkey operation is rate limited per netuid
     SetSNOwnerHotkey(NetUid),
+    // Subnet registration rate limit
+    NetworkLastRegistered,
+    // Last tx block limit per account ID
+    LastTxBlock(AccountId),
+    // Last tx block child key limit per account ID
+    LastTxBlockChildKeyTake(AccountId),
+    // Last tx block delegate key limit per account ID
+    LastTxBlockDelegateTake(AccountId),
 }
 
 pub trait ProxyInterface<AccountId> {

pallets/subtensor/src/macros/dispatches.rs

@@ -2031,7 +2031,7 @@ mod dispatches {
         /// * commit_reveal_version (`u16`):
         ///     - The client (bittensor-drand) version
         #[pallet::call_index(113)]
-        #[pallet::weight((Weight::from_parts(64_530_000, 0)
+        #[pallet::weight((Weight::from_parts(80_690_000, 0)
 		.saturating_add(T::DbWeight::get().reads(7_u64))
 		.saturating_add(T::DbWeight::get().writes(2)), DispatchClass::Normal, Pays::No))]
         pub fn commit_timelocked_weights(

pallets/subtensor/src/macros/hooks.rs

@@ -135,7 +135,9 @@ mod hooks {
                 //Migrate CRV3 to TimelockedCommits
                 .saturating_add(migrations::migrate_crv3_v2_to_timelocked::migrate_crv3_v2_to_timelocked::<T>())
                 // Migrate to fix root counters
-                .saturating_add(migrations::migrate_fix_root_tao_and_alpha_in::migrate_fix_root_tao_and_alpha_in::<T>());
+                .saturating_add(migrations::migrate_fix_root_tao_and_alpha_in::migrate_fix_root_tao_and_alpha_in::<T>())
+                // Migrate last block rate limiting storage items
+                .saturating_add(migrations::migrate_rate_limiting_last_blocks::migrate_obsolete_rate_limiting_last_blocks_storage::<T>());
             weight
         }