Add subnet and staking helper precompile functions to test e2e

Author: axionyu

runtime/src/precompiles/staking.rs

@@ -26,7 +26,7 @@
 //
 
 use pallet_evm::BalanceConverter;
-use pallet_evm::{ExitError, PrecompileFailure, PrecompileHandle, PrecompileResult};
+use pallet_evm::{ExitError, ExitSucceed, PrecompileOutput, PrecompileFailure, PrecompileHandle, PrecompileResult};
 use sp_core::U256;
 use sp_runtime::traits::UniqueSaturatedInto;
 
@@ -54,11 +54,39 @@ impl StakingPrecompile {
             id if id == get_method_id("removeStake(bytes32,uint256,uint16)") => {
                 Self::remove_stake(handle, &method_input)
             }
+            id if id == get_method_id("getStake(bytes32,bytes32,uint16)") => {
+                Self::get_stake(&method_input)
+            }
             _ => Err(PrecompileFailure::Error {
                 exit_status: ExitError::InvalidRange,
             }),
         }
     }
+    fn get_stake(data: &[u8]) -> PrecompileResult {
+        let mut coldkey = [0u8; 32];
+        coldkey.copy_from_slice(get_slice(data, 0, 32)?);
+
+        let mut hotkey = [0u8; 32];
+        hotkey.copy_from_slice(get_slice(data, 32, 64)?);
+
+		let coldkey = coldkey.into();
+		let hotkey = hotkey.into();
+
+        let stake = pallet_subtensor::Pallet::<Runtime>::get_stake_for_coldkey_and_hotkey(&coldkey, &hotkey);
+
+        let result_u256 = U256::from(stake);
+        let amount_sub =
+            <Runtime as pallet_evm::Config>::BalanceConverter::into_evm_balance(result_u256)
+                .ok_or(ExitError::OutOfFund)?;
+
+        let mut result = [0_u8; 32];
+        U256::to_big_endian(&amount_sub, &mut result);
+
+        Ok(PrecompileOutput {
+            exit_status: ExitSucceed::Returned,
+            output: result.into(),
+        })
+    }
 
     fn add_stake(handle: &mut impl PrecompileHandle, data: &[u8]) -> PrecompileResult {
         let hotkey = Self::parse_hotkey(data)?.into();
@@ -106,4 +134,5 @@ impl StakingPrecompile {
         hotkey.copy_from_slice(get_slice(data, 0, 32)?);
         Ok(hotkey)
     }
+
 }

runtime/src/precompiles/subnet.rs

@@ -1,8 +1,10 @@
 use crate::precompiles::{dispatch, get_method_id, get_slice};
 use crate::{ Runtime, RuntimeCall};
-use pallet_evm::{AddressMapping, ExitError, PrecompileFailure, PrecompileHandle, PrecompileResult, HashedAddressMapping };
+use pallet_evm::{AddressMapping, ExitError, ExitSucceed, PrecompileFailure, PrecompileOutput, PrecompileHandle, PrecompileResult, HashedAddressMapping };
 use sp_std::vec;
 use sp_runtime::AccountId32;
+use sp_core::{ U256};
+
 use sp_runtime::traits::BlakeTwo256;
 
 pub const SUBNET_PRECOMPILE_INDEX: u64 = 2051;
@@ -38,6 +40,9 @@ impl SubnetPrecompile {
             id if id == get_method_id("registerNetwork()") => {
                 Self::register_network(handle, &[0_u8; 0])
             }
+            id if id == get_method_id("getTempo(uint16)") => {
+                Self::get_tempo(&method_input)
+            }
             _ => Err(PrecompileFailure::Error {
                 exit_status: ExitError::InvalidRange,
             }),
@@ -60,6 +65,18 @@ impl SubnetPrecompile {
         dispatch(handle, call, STAKING_CONTRACT_ADDRESS)
 	}
 
+	fn get_tempo(data: &[u8]) -> PrecompileResult {
+		let netuid = Self::parse_netuid(data)?;
+		let tempo = pallet_subtensor::Pallet::<Runtime>::get_tempo(netuid);
+        let result_u256 = U256::from(tempo);
+        let mut result = [0_u8; 32];
+        U256::to_big_endian(&result_u256, &mut result);
+        Ok(PrecompileOutput {
+            exit_status: ExitSucceed::Returned,
+            output: result.into(),
+        })
+	}
+
     fn parse_netuid(data: &[u8]) -> Result<u16, PrecompileFailure> {
         if data.len() < 32 {
             return Err(PrecompileFailure::Error {