Merge remote-tracking branch 'origin/devnet-ready' into sam-fix-try-runtime

Author: sam0x17

.github/workflows/require-clean-merges.yml

@@ -46,6 +46,10 @@ jobs:
           git checkout $PR_BRANCH
           git reset --hard origin/$PR_BRANCH
 
+          # Configure a temporary Git identity to allow merging
+          git config --local user.email "[email protected]"
+          git config --local user.name "GitHub Actions"
+
           for branch in $MERGE_BRANCHES; do
             echo "Checking merge from $branch into $PR_BRANCH..."
             

pallets/admin-utils/src/lib.rs

@@ -23,9 +23,9 @@ mod tests;
 #[frame_support::pallet]
 pub mod pallet {
     use super::*;
-    use frame_support::dispatch::DispatchResult;
     use frame_support::pallet_prelude::*;
     use frame_support::traits::tokens::Balance;
+    use frame_support::{dispatch::DispatchResult, pallet_prelude::StorageMap};
     use frame_system::pallet_prelude::*;
     use pallet_evm_chain_id::{self, ChainId};
     use sp_runtime::BoundedVec;
@@ -69,7 +69,16 @@ pub mod pallet {
     }
 
     #[pallet::event]
-    pub enum Event<T: Config> {}
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        /// Event emitted when a precompile operation is updated.
+        PrecompileUpdated {
+            /// The type of precompile operation being updated.
+            precompile_id: PrecompileEnum,
+            /// Indicates if the precompile operation is enabled or not.
+            enabled: bool,
+        },
+    }
 
     // Errors inform users that something went wrong.
     #[pallet::error]
@@ -81,6 +90,37 @@ pub mod pallet {
         /// The maximum number of subnet validators must be more than the current number of UIDs already in the subnet.
         MaxAllowedUIdsLessThanCurrentUIds,
     }
+    /// Enum for specifying the type of precompile operation.
+    #[derive(Encode, Decode, TypeInfo, Clone, PartialEq, Eq, Debug, Copy)]
+    pub enum PrecompileEnum {
+        /// Enum for balance transfer precompile
+        BalanceTransfer,
+        /// Enum for staking precompile
+        Staking,
+        /// Enum for subnet precompile
+        Subnet,
+        /// Enum for metagraph precompile
+        Metagraph,
+        /// Enum for neuron precompile
+        Neuron,
+    }
+
+    #[pallet::type_value]
+    /// Default value for precompile enable
+    pub fn DefaultPrecompileEnabled<T: Config>() -> bool {
+        true
+    }
+
+    #[pallet::storage]
+    /// Map PrecompileEnum --> enabled
+    pub type PrecompileEnable<T: Config> = StorageMap<
+        _,
+        Blake2_128Concat,
+        PrecompileEnum,
+        bool,
+        ValueQuery,
+        DefaultPrecompileEnabled<T>,
+    >;
 
     /// Dispatchable functions allows users to interact with the pallet and invoke state changes.
     #[pallet::call]
@@ -613,7 +653,7 @@ pub mod pallet {
             netuid: u16,
             difficulty: u64,
         ) -> DispatchResult {
-            pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
+            ensure_root(origin)?;
             ensure!(
                 pallet_subtensor::Pallet::<T>::if_subnet_exist(netuid),
                 Error::<T>::SubnetDoesNotExist
@@ -1307,6 +1347,36 @@ pub mod pallet {
             pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
             pallet_subtensor::Pallet::<T>::toggle_transfer(netuid, toggle)
         }
+
+        /// Toggles the enablement of an EVM precompile.
+        ///
+        /// # Arguments
+        /// * `origin` - The origin of the call, which must be the root account.
+        /// * `precompile_id` - The identifier of the EVM precompile to toggle.
+        /// * `enabled` - The new enablement state of the precompile.
+        ///
+        /// # Errors
+        /// * `BadOrigin` - If the caller is not the root account.
+        ///
+        /// # Weight
+        /// Weight is handled by the `#[pallet::weight]` attribute.
+        #[pallet::call_index(62)]
+        #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
+        pub fn sudo_toggle_evm_precompile(
+            origin: OriginFor<T>,
+            precompile_id: PrecompileEnum,
+            enabled: bool,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+            if PrecompileEnable::<T>::get(precompile_id) != enabled {
+                PrecompileEnable::<T>::insert(precompile_id, enabled);
+                Self::deposit_event(Event::PrecompileUpdated {
+                    precompile_id,
+                    enabled,
+                });
+            }
+            Ok(())
+        }
     }
 }
 

pallets/admin-utils/src/tests/mock.rs

@@ -392,6 +392,7 @@ pub(crate) fn run_to_block(n: u64) {
     while System::block_number() < n {
         SubtensorModule::on_finalize(System::block_number());
         System::on_finalize(System::block_number());
+        System::reset_events();
         System::set_block_number(System::block_number() + 1);
         System::on_initialize(System::block_number());
         SubtensorModule::on_initialize(System::block_number());

pallets/admin-utils/src/tests/mod.rs

@@ -11,6 +11,7 @@ use pallet_subtensor::Event;
 use sp_consensus_grandpa::AuthorityId as GrandpaId;
 use sp_core::{ed25519, Pair, U256};
 
+use crate::pallet::PrecompileEnable;
 use crate::Error;
 use mock::*;
 
@@ -642,6 +643,18 @@ fn test_sudo_set_difficulty() {
             to_be_set
         ));
         assert_eq!(SubtensorModule::get_difficulty_as_u64(netuid), to_be_set);
+
+        // Test that SN owner can't set difficulty
+        pallet_subtensor::SubnetOwner::<Test>::insert(netuid, U256::from(1));
+        assert_eq!(
+            AdminUtils::sudo_set_difficulty(
+                <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
+                netuid,
+                init_value
+            ),
+            Err(DispatchError::BadOrigin)
+        );
+        assert_eq!(SubtensorModule::get_difficulty_as_u64(netuid), to_be_set); // no change
     });
 }
 
@@ -1365,3 +1378,74 @@ fn test_schedule_grandpa_change() {
         assert_eq!(Grandpa::grandpa_authorities(), vec![(bob, 1)]);
     });
 }
+
+#[test]
+fn test_sudo_toggle_evm_precompile() {
+    new_test_ext().execute_with(|| {
+        let precompile_id = crate::PrecompileEnum::BalanceTransfer;
+        let initial_enabled = PrecompileEnable::<Test>::get(precompile_id);
+        assert!(initial_enabled); // Assuming the default is true
+
+        run_to_block(1);
+
+        assert_eq!(
+            AdminUtils::sudo_toggle_evm_precompile(
+                <<Test as Config>::RuntimeOrigin>::signed(U256::from(0)),
+                precompile_id,
+                false
+            ),
+            Err(DispatchError::BadOrigin)
+        );
+
+        assert_ok!(AdminUtils::sudo_toggle_evm_precompile(
+            RuntimeOrigin::root(),
+            precompile_id,
+            false
+        ));
+
+        assert_eq!(
+            System::events()
+                .iter()
+                .filter(|r| r.event
+                    == RuntimeEvent::AdminUtils(crate::Event::PrecompileUpdated {
+                        precompile_id,
+                        enabled: false
+                    }))
+                .count(),
+            1
+        );
+
+        let updated_enabled = PrecompileEnable::<Test>::get(precompile_id);
+        assert!(!updated_enabled);
+
+        run_to_block(2);
+
+        assert_ok!(AdminUtils::sudo_toggle_evm_precompile(
+            RuntimeOrigin::root(),
+            precompile_id,
+            false
+        ));
+
+        // no event without status change
+        assert_eq!(
+            System::events()
+                .iter()
+                .filter(|r| r.event
+                    == RuntimeEvent::AdminUtils(crate::Event::PrecompileUpdated {
+                        precompile_id,
+                        enabled: false
+                    }))
+                .count(),
+            0
+        );
+
+        assert_ok!(AdminUtils::sudo_toggle_evm_precompile(
+            RuntimeOrigin::root(),
+            precompile_id,
+            true
+        ));
+
+        let final_enabled = PrecompileEnable::<Test>::get(precompile_id);
+        assert!(final_enabled);
+    });
+}

pallets/subtensor/src/lib.rs

@@ -1674,6 +1674,10 @@ pub enum CustomTransactionError {
     InsufficientLiquidity,
     SlippageTooHigh,
     TransferDisallowed,
+    HotKeyNotRegisteredInNetwork,
+    InvalidIpAddress,
+    ServingRateLimitExceeded,
+    InvalidPort,
     BadRequest,
 }
 
@@ -1690,6 +1694,10 @@ impl From<CustomTransactionError> for u8 {
             CustomTransactionError::InsufficientLiquidity => 7,
             CustomTransactionError::SlippageTooHigh => 8,
             CustomTransactionError::TransferDisallowed => 9,
+            CustomTransactionError::HotKeyNotRegisteredInNetwork => 10,
+            CustomTransactionError::InvalidIpAddress => 11,
+            CustomTransactionError::ServingRateLimitExceeded => 12,
+            CustomTransactionError::InvalidPort => 13,
             CustomTransactionError::BadRequest => 255,
         }
     }
@@ -1773,6 +1781,22 @@ where
                     CustomTransactionError::TransferDisallowed.into(),
                 )
                 .into()),
+                Error::<T>::HotKeyNotRegisteredInNetwork => Err(InvalidTransaction::Custom(
+                    CustomTransactionError::HotKeyNotRegisteredInNetwork.into(),
+                )
+                .into()),
+                Error::<T>::InvalidIpAddress => Err(InvalidTransaction::Custom(
+                    CustomTransactionError::InvalidIpAddress.into(),
+                )
+                .into()),
+                Error::<T>::ServingRateLimitExceeded => Err(InvalidTransaction::Custom(
+                    CustomTransactionError::ServingRateLimitExceeded.into(),
+                )
+                .into()),
+                Error::<T>::InvalidPort => Err(InvalidTransaction::Custom(
+                    CustomTransactionError::InvalidPort.into(),
+                )
+                .into()),
                 _ => Err(
                     InvalidTransaction::Custom(CustomTransactionError::BadRequest.into()).into(),
                 ),
@@ -2175,6 +2199,32 @@ where
                     })
                 }
             }
+            Some(Call::serve_axon {
+                netuid,
+                version,
+                ip,
+                port,
+                ip_type,
+                protocol,
+                placeholder1,
+                placeholder2,
+            }) => {
+                // Fully validate the user input
+                Self::result_to_validity(
+                    Pallet::<T>::validate_serve_axon(
+                        who,
+                        *netuid,
+                        *version,
+                        *ip,
+                        *port,
+                        *ip_type,
+                        *protocol,
+                        *placeholder1,
+                        *placeholder2,
+                    ),
+                    Self::get_priority_vanilla(),
+                )
+            }
             _ => {
                 if let Some(
                     BalancesCall::transfer_keep_alive { .. }

pallets/subtensor/src/macros/hooks.rs

@@ -81,7 +81,9 @@ mod hooks {
                 // Upgrade identities to V2
                 .saturating_add(migrations::migrate_identities_v2::migrate_identities_to_v2::<T>())
 				// Set the min burn across all subnets to a new minimum
-				.saturating_add(migrations::migrate_set_min_burn::migrate_set_min_burn::<T>());
+				.saturating_add(migrations::migrate_set_min_burn::migrate_set_min_burn::<T>())
+				// Set the min difficulty across all subnets to a new minimum
+				.saturating_add(migrations::migrate_set_min_difficulty::migrate_set_min_difficulty::<T>());
             weight
         }
 

pallets/subtensor/src/migrations/migrate_set_min_difficulty.rs

@@ -0,0 +1,52 @@
+use alloc::string::String;
+
+use frame_support::IterableStorageMap;
+use frame_support::{traits::Get, weights::Weight};
+
+use super::*;
+
+pub fn migrate_set_min_difficulty<T: Config>() -> Weight {
+    let migration_name = b"migrate_set_min_difficulty".to_vec();
+
+    // Initialize the weight with one read operation.
+    let mut weight = T::DbWeight::get().reads(1);
+
+    // Check if the migration has already run
+    if HasMigrationRun::<T>::get(&migration_name) {
+        log::info!(
+            "Migration '{:?}' has already run. Skipping.",
+            migration_name
+        );
+        return weight;
+    }
+    log::info!(
+        "Running migration '{}'",
+        String::from_utf8_lossy(&migration_name)
+    );
+
+    let netuids: Vec<u16> = <NetworksAdded<T> as IterableStorageMap<u16, bool>>::iter()
+        .map(|(netuid, _)| netuid)
+        .collect();
+    weight = weight.saturating_add(T::DbWeight::get().reads(netuids.len() as u64));
+
+    for netuid in netuids.iter().clone() {
+        if *netuid == 0 {
+            continue;
+        }
+        // Set min difficulty to 10 million for all subnets
+        Pallet::<T>::set_min_difficulty(*netuid, 10_000_000);
+        weight = weight.saturating_add(T::DbWeight::get().writes(1));
+    }
+
+    // Mark the migration as completed
+    HasMigrationRun::<T>::insert(&migration_name, true);
+    weight = weight.saturating_add(T::DbWeight::get().writes(1));
+
+    log::info!(
+        "Migration '{:?}' completed.",
+        String::from_utf8_lossy(&migration_name)
+    );
+
+    // Return the migration weight.
+    weight
+}

pallets/subtensor/src/migrations/mod.rs

@@ -12,6 +12,7 @@ pub mod migrate_populate_owned_hotkeys;
 pub mod migrate_populate_staking_hotkeys;
 pub mod migrate_rao;
 pub mod migrate_set_min_burn;
+pub mod migrate_set_min_difficulty;
 pub mod migrate_stake_threshold;
 pub mod migrate_subnet_volume;
 pub mod migrate_to_v1_separate_emission;