Merge branch 'devnet-ready' into refactor-extension2

Author: shamil-gadelshin

Cargo.lock

@@ -52,6 +52,10 @@ COPY --from=builder /build/snapshot.json /snapshot.json
 COPY --from=builder /build/scripts/localnet.sh scripts/localnet.sh
 RUN chmod +x /scripts/localnet.sh
 
+# Copy WebAssembly artifacts
+COPY --from=builder /build/target/fast-runtime/release/wbuild/node-subtensor-runtime/node_subtensor_runtime.compact.compressed.wasm target/fast-runtime/release/node_subtensor_runtime.compact.compressed.wasm
+COPY --from=builder /build/target/non-fast-runtime/release/wbuild/node-subtensor-runtime/node_subtensor_runtime.compact.compressed.wasm target/non-fast-runtime/release/node_subtensor_runtime.compact.compressed.wasm
+
 ## Ubdate certificates
 RUN apt-get update && apt-get install -y ca-certificates
 

Dockerfile-localnet

@@ -168,30 +168,31 @@ export async function waitForTransactionCompletion(api: TypedApi<typeof devnet>,
     // })
 }
 
+
 export async function getTransactionWatchPromise(tx: Transaction<{}, string, string, void>, signer: PolkadotSigner,) {
     return new Promise<void>((resolve, reject) => {
         // store the txHash, then use it in timeout. easier to know which tx is not finalized in time
         let txHash = ""
         const subscription = tx.signSubmitAndWatch(signer).subscribe({
             next(value) {
-                console.log("Event:", value);
                 txHash = value.txHash
 
                 // TODO investigate why finalized not for each extrinsic
                 if (value.type === "finalized") {
                     console.log("Transaction is finalized in block:", value.txHash);
                     subscription.unsubscribe();
+                    clearTimeout(timeoutId);
                     if (!value.ok) {
                         console.log("Transaction threw an error:", value.dispatchError)
                     }
                     // Resolve the promise when the transaction is finalized
                     resolve();
-
                 }
             },
             error(err) {
                 console.error("Transaction failed:", err);
                 subscription.unsubscribe();
+                clearTimeout(timeoutId);
                 // Reject the promise in case of an error
                 reject(err);
 
@@ -201,7 +202,7 @@ export async function getTransactionWatchPromise(tx: Transaction<{}, string, str
             }
         });
 
-        setTimeout(() => {
+        const timeoutId = setTimeout(() => {
             subscription.unsubscribe();
             console.log('unsubscribed because of timeout for tx {}', txHash);
             reject()

evm-tests/src/substrate.ts

@@ -1673,6 +1673,21 @@ pub mod pallet {
             pallet_subtensor::Pallet::<T>::set_commit_reveal_weights_version(version);
             Ok(())
         }
+
+        /// Sets the number of immune owner neurons
+        #[pallet::call_index(72)]
+        #[pallet::weight(Weight::from_parts(15_000_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_owner_immune_neuron_limit(
+            origin: OriginFor<T>,
+            netuid: NetUid,
+            immune_neurons: u16,
+        ) -> DispatchResult {
+            pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
+            pallet_subtensor::Pallet::<T>::set_owner_immune_neuron_limit(netuid, immune_neurons)?;
+            Ok(())
+        }
     }
 }
 

…tests/test/uid.precompile.lookup.test.ts …s/test/evm-uid.precompile.lookup.test.tsevm-tests/test/uid.precompile.lookup.test.ts renamed to evm-tests/test/evm-uid.precompile.lookup.test.ts evm-tests/test/uid.precompile.lookup.test.ts renamed to evm-tests/test/evm-uid.precompile.lookup.test.ts

@@ -45,9 +45,9 @@ impl<T: Config> Pallet<T> {
         let reveal_epoch = cur_epoch.saturating_sub(reveal_period);
 
         // Clean expired commits
-        for (epoch, _) in CRV3WeightCommitsV2::<T>::iter_prefix(netuid) {
+        for (epoch, _) in TimelockedWeightCommits::<T>::iter_prefix(netuid) {
             if epoch < reveal_epoch {
-                CRV3WeightCommitsV2::<T>::remove(netuid, epoch);
+                TimelockedWeightCommits::<T>::remove(netuid, epoch);
             }
         }
 
@@ -57,7 +57,7 @@ impl<T: Config> Pallet<T> {
             return Ok(());
         }
 
-        let mut entries = CRV3WeightCommitsV2::<T>::take(netuid, reveal_epoch);
+        let mut entries = TimelockedWeightCommits::<T>::take(netuid, reveal_epoch);
         let mut unrevealed = VecDeque::new();
 
         // Keep popping items off the front of the queue until we successfully reveal a commit.
@@ -185,11 +185,11 @@ impl<T: Config> Pallet<T> {
                 continue;
             }
 
-            Self::deposit_event(Event::CRV3WeightsRevealed(netuid, who));
+            Self::deposit_event(Event::TimelockedWeightsRevealed(netuid, who));
         }
 
         if !unrevealed.is_empty() {
-            CRV3WeightCommitsV2::<T>::insert(netuid, reveal_epoch, unrevealed);
+            TimelockedWeightCommits::<T>::insert(netuid, reveal_epoch, unrevealed);
         }
 
         Ok(())

pallets/admin-utils/src/lib.rs

@@ -426,6 +426,47 @@ impl<T: Config> Pallet<T> {
         (prop_alpha_dividends, tao_dividends)
     }
 
+    fn get_immune_owner_hotkeys(netuid: NetUid, coldkey: &T::AccountId) -> Vec<T::AccountId> {
+        // Gather (block, uid, hotkey) only for hotkeys that have a UID and a registration block.
+        let mut triples: Vec<(u64, u16, T::AccountId)> = OwnedHotkeys::<T>::get(coldkey)
+            .into_iter()
+            .filter_map(|hotkey| {
+                // Uids must exist, filter_map ignores hotkeys without UID
+                Uids::<T>::get(netuid, &hotkey).map(|uid| {
+                    let block = BlockAtRegistration::<T>::get(netuid, uid);
+                    (block, uid, hotkey)
+                })
+            })
+            .collect();
+
+        // Sort by BlockAtRegistration (descending), then by uid (ascending)
+        // Recent registration is priority so that we can let older keys expire (get non-immune)
+        triples.sort_by(|(b1, u1, _), (b2, u2, _)| b2.cmp(b1).then(u1.cmp(u2)));
+
+        // Keep first ImmuneOwnerUidsLimit
+        let limit = ImmuneOwnerUidsLimit::<T>::get(netuid).into();
+        if triples.len() > limit {
+            triples.truncate(limit);
+        }
+
+        // Project to just hotkeys
+        let mut immune_hotkeys: Vec<T::AccountId> =
+            triples.into_iter().map(|(_, _, hk)| hk).collect();
+
+        // Insert subnet owner hotkey in the beginning of the list if valid and not
+        // already present
+        if let Ok(owner_hk) = SubnetOwnerHotkey::<T>::try_get(netuid) {
+            if Uids::<T>::get(netuid, &owner_hk).is_some() && !immune_hotkeys.contains(&owner_hk) {
+                immune_hotkeys.insert(0, owner_hk);
+                if immune_hotkeys.len() > limit {
+                    immune_hotkeys.truncate(limit);
+                }
+            }
+        }
+
+        immune_hotkeys
+    }
+
     pub fn distribute_dividends_and_incentives(
         netuid: NetUid,
         owner_cut: AlphaCurrency,
@@ -454,17 +495,20 @@ impl<T: Config> Pallet<T> {
         }
 
         // Distribute mining incentives.
+        let subnet_owner_coldkey = SubnetOwner::<T>::get(netuid);
+        let owner_hotkeys = Self::get_immune_owner_hotkeys(netuid, &subnet_owner_coldkey);
+        log::debug!("incentives: owner hotkeys: {owner_hotkeys:?}");
         for (hotkey, incentive) in incentives {
             log::debug!("incentives: hotkey: {incentive:?}");
 
-            if let Ok(owner_hotkey) = SubnetOwnerHotkey::<T>::try_get(netuid) {
-                if hotkey == owner_hotkey {
-                    log::debug!(
-                        "incentives: hotkey: {hotkey:?} is SN owner hotkey, skipping {incentive:?}"
-                    );
-                    continue; // Skip/burn miner-emission for SN owner hotkey.
-                }
+            // Skip/burn miner-emission for immune keys
+            if owner_hotkeys.contains(&hotkey) {
+                log::debug!(
+                    "incentives: hotkey: {hotkey:?} is SN owner hotkey or associated hotkey, skipping {incentive:?}"
+                );
+                continue;
             }
+
             // Increase stake for miner.
             Self::increase_stake_for_hotkey_and_coldkey_on_subnet(
                 &hotkey.clone(),

pallets/subtensor/src/coinbase/reveal_commits.rs

@@ -607,7 +607,7 @@ impl<T: Config> Pallet<T> {
             }
 
             // ---------- v3 ------------------------------------------------------
-            for (_epoch, q) in CRV3WeightCommitsV2::<T>::iter_prefix(netuid) {
+            for (_epoch, q) in TimelockedWeightCommits::<T>::iter_prefix(netuid) {
                 for (who, cb, ..) in q.iter() {
                     if !Self::is_commit_expired(netuid, *cb) {
                         if let Some(i) = uid_of(who) {

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -1457,6 +1457,26 @@ pub mod pallet {
     pub type SubtokenEnabled<T> =
         StorageMap<_, Identity, NetUid, bool, ValueQuery, DefaultFalse<T>>;
 
+    #[pallet::type_value]
+    /// Default value for burn keys limit
+    pub fn DefaultImmuneOwnerUidsLimit<T: Config>() -> u16 {
+        1
+    }
+    #[pallet::type_value]
+    /// Maximum value for burn keys limit
+    pub fn MaxImmuneOwnerUidsLimit<T: Config>() -> u16 {
+        10
+    }
+    #[pallet::type_value]
+    /// Minimum value for burn keys limit
+    pub fn MinImmuneOwnerUidsLimit<T: Config>() -> u16 {
+        1
+    }
+    #[pallet::storage]
+    /// --- MAP ( netuid ) --> Burn key limit
+    pub type ImmuneOwnerUidsLimit<T> =
+        StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultImmuneOwnerUidsLimit<T>>;
+
     /// =======================================
     /// ==== Subnetwork Consensus Storage  ====
     /// =======================================
@@ -1657,6 +1677,23 @@ pub mod pallet {
         OptionQuery,
     >;
     #[pallet::storage]
+    /// MAP (netuid, epoch) → VecDeque<(who, commit_block, ciphertext, reveal_round)>
+    /// Stores a queue of weight commits for an account on a given subnet.
+    pub type TimelockedWeightCommits<T: Config> = StorageDoubleMap<
+        _,
+        Twox64Concat,
+        NetUid,
+        Twox64Concat,
+        u64, // epoch key
+        VecDeque<(
+            T::AccountId,
+            u64, // commit_block
+            BoundedVec<u8, ConstU32<MAX_CRV3_COMMIT_SIZE_BYTES>>,
+            RoundNumber,
+        )>,
+        ValueQuery,
+    >;
+    #[pallet::storage]
     /// MAP (netuid, epoch) → VecDeque<(who, ciphertext, reveal_round)>
     /// DEPRECATED for CRV3WeightCommitsV2
     pub type CRV3WeightCommits<T: Config> = StorageDoubleMap<
@@ -1674,7 +1711,7 @@ pub mod pallet {
     >;
     #[pallet::storage]
     /// MAP (netuid, epoch) → VecDeque<(who, commit_block, ciphertext, reveal_round)>
-    /// Stores a queue of v3 commits for an account on a given netuid.
+    /// DEPRECATED for TimelockedWeightCommits
     pub type CRV3WeightCommitsV2<T: Config> = StorageDoubleMap<
         _,
         Twox64Concat,

pallets/subtensor/src/epoch/run_epoch.rs

@@ -693,7 +693,7 @@ mod dispatches {
         /// 	- Attempting to set prometheus information withing the rate limit min.
         ///
         #[pallet::call_index(4)]
-        #[pallet::weight((Weight::from_parts(33_780_000, 0)
+        #[pallet::weight((Weight::from_parts(33_010_000, 0)
 		.saturating_add(T::DbWeight::get().reads(4))
 		.saturating_add(T::DbWeight::get().writes(1)), DispatchClass::Normal, Pays::No))]
         pub fn serve_axon(
@@ -2201,7 +2201,7 @@ mod dispatches {
         /// * commit_reveal_version (`u16`):
         ///     - The client (bittensor-drand) version
         #[pallet::call_index(113)]
-        #[pallet::weight((Weight::from_parts(64_220_000, 0)
+        #[pallet::weight((Weight::from_parts(64_530_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(