testnet deploy 2/14/2025 number 2

.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 "github-actions@github.com"
+          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]
@@ -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::*;
 
@@ -1365,3 +1366,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 { .. }