Merge pull request #1110 from opentensor/neuron-precompile

add subnets precompile

Author: sam0x17

runtime/src/precompiles/balance_transfer.rs

@@ -1,18 +1,15 @@
-use frame_system::RawOrigin;
 use pallet_evm::{
     BalanceConverter, ExitError, ExitSucceed, PrecompileHandle, PrecompileOutput, PrecompileResult,
 };
 use sp_runtime::traits::UniqueSaturatedInto;
 use sp_std::vec;
 
 use crate::precompiles::{
-    bytes_to_account_id, get_method_id, get_slice, try_dispatch_runtime_call,
+    contract_to_origin, get_method_id, get_pubkey, get_slice, try_dispatch_runtime_call,
 };
 use crate::Runtime;
 
 pub const BALANCE_TRANSFER_INDEX: u64 = 2048;
-
-// This is a hardcoded hashed address mapping of 0x0000000000000000000000000000000000000800 to an
 // ss58 public key i.e., the contract sends funds it received to the destination address from the
 // method parameter.
 const CONTRACT_ADDRESS_SS58: [u8; 32] = [
@@ -51,15 +48,13 @@ impl BalanceTransferPrecompile {
         }
 
         let address_bytes_dst = get_slice(txdata, 4, 36)?;
-        let account_id_src = bytes_to_account_id(&CONTRACT_ADDRESS_SS58)?;
-        let account_id_dst = bytes_to_account_id(address_bytes_dst)?;
+        let (account_id_dst, _) = get_pubkey(address_bytes_dst)?;
 
         let call = pallet_balances::Call::<Runtime>::transfer_allow_death {
             dest: account_id_dst.into(),
             value: amount_sub.unique_saturated_into(),
         };
-        let origin = RawOrigin::Signed(account_id_src);
 
-        try_dispatch_runtime_call(handle, call, origin)
+        try_dispatch_runtime_call(handle, call, contract_to_origin(&CONTRACT_ADDRESS_SS58)?)
     }
 }

runtime/src/precompiles/mod.rs

@@ -4,7 +4,7 @@ use alloc::format;
 use core::marker::PhantomData;
 
 use frame_support::dispatch::{GetDispatchInfo, Pays};
-use frame_system::RawOrigin;
+
 use pallet_evm::{
     ExitError, ExitSucceed, GasWeightMapping, IsPrecompileResult, Precompile, PrecompileFailure,
     PrecompileHandle, PrecompileOutput, PrecompileResult, PrecompileSet,
@@ -17,19 +17,25 @@ use sp_runtime::{traits::Dispatchable, AccountId32};
 
 use crate::{Runtime, RuntimeCall};
 
+use frame_system::RawOrigin;
+
+use sp_std::vec;
+
 // Include custom precompiles
 mod balance_transfer;
 mod ed25519;
 mod metagraph;
+mod neuron;
 mod staking;
+mod subnet;
 
 use balance_transfer::*;
 use ed25519::*;
 use metagraph::*;
+use neuron::*;
 use staking::*;
-
+use subnet::*;
 pub struct FrontierPrecompiles<R>(PhantomData<R>);
-
 impl<R> Default for FrontierPrecompiles<R>
 where
     R: pallet_evm::Config,
@@ -46,7 +52,7 @@ where
     pub fn new() -> Self {
         Self(Default::default())
     }
-    pub fn used_addresses() -> [H160; 11] {
+    pub fn used_addresses() -> [H160; 13] {
         [
             hash(1),
             hash(2),
@@ -58,7 +64,9 @@ where
             hash(EDVERIFY_PRECOMPILE_INDEX),
             hash(BALANCE_TRANSFER_INDEX),
             hash(STAKING_PRECOMPILE_INDEX),
+            hash(SUBNET_PRECOMPILE_INDEX),
             hash(METAGRAPH_PRECOMPILE_INDEX),
+            hash(NEURON_PRECOMPILE_INDEX),
         ]
     }
 }
@@ -83,9 +91,11 @@ where
                 Some(BalanceTransferPrecompile::execute(handle))
             }
             a if a == hash(STAKING_PRECOMPILE_INDEX) => Some(StakingPrecompile::execute(handle)),
+            a if a == hash(SUBNET_PRECOMPILE_INDEX) => Some(SubnetPrecompile::execute(handle)),
             a if a == hash(METAGRAPH_PRECOMPILE_INDEX) => {
                 Some(MetagraphPrecompile::execute(handle))
             }
+            a if a == hash(NEURON_PRECOMPILE_INDEX) => Some(NeuronPrecompile::execute(handle)),
 
             _ => None,
         }
@@ -113,31 +123,55 @@ pub fn get_method_id(method_signature: &str) -> [u8; 4] {
     [hash[0], hash[1], hash[2], hash[3]]
 }
 
-/// Convert bytes to AccountId32 with PrecompileFailure as Error
-/// which consumes all gas
-///
-pub fn bytes_to_account_id(account_id_bytes: &[u8]) -> Result<AccountId32, PrecompileFailure> {
-    AccountId32::try_from(account_id_bytes).map_err(|_| {
-        log::info!("Error parsing account id bytes {:?}", account_id_bytes);
-        PrecompileFailure::Error {
-            exit_status: ExitError::InvalidRange,
-        }
-    })
-}
-
 /// Takes a slice from bytes with PrecompileFailure as Error
 ///
 pub fn get_slice(data: &[u8], from: usize, to: usize) -> Result<&[u8], PrecompileFailure> {
     let maybe_slice = data.get(from..to);
     if let Some(slice) = maybe_slice {
         Ok(slice)
     } else {
+        log::error!(
+            "fail to get slice from data, {:?}, from {}, to {}",
+            &data,
+            from,
+            to
+        );
         Err(PrecompileFailure::Error {
             exit_status: ExitError::InvalidRange,
         })
     }
 }
 
+pub fn get_pubkey(data: &[u8]) -> Result<(AccountId32, vec::Vec<u8>), PrecompileFailure> {
+    let mut pubkey = [0u8; 32];
+    pubkey.copy_from_slice(get_slice(data, 0, 32)?);
+
+    Ok((
+        pubkey.into(),
+        data.get(4..)
+            .map_or_else(vec::Vec::new, |slice| slice.to_vec()),
+    ))
+}
+
+fn parse_netuid(data: &[u8], offset: usize) -> Result<u16, PrecompileFailure> {
+    if data.len() < offset + 2 {
+        return Err(PrecompileFailure::Error {
+            exit_status: ExitError::InvalidRange,
+        });
+    }
+
+    let mut netuid_bytes = [0u8; 2];
+    netuid_bytes.copy_from_slice(get_slice(data, offset, offset + 2)?);
+    let netuid: u16 = netuid_bytes[1] as u16 | ((netuid_bytes[0] as u16) << 8u16);
+
+    Ok(netuid)
+}
+
+fn contract_to_origin(contract: &[u8; 32]) -> Result<RawOrigin<AccountId32>, PrecompileFailure> {
+    let (account_id, _) = get_pubkey(contract)?;
+    Ok(RawOrigin::Signed(account_id))
+}
+
 /// Dispatches a runtime call, but also checks and records the gas costs.
 fn try_dispatch_runtime_call(
     handle: &mut impl PrecompileHandle,

runtime/src/precompiles/neuron.rs

@@ -0,0 +1,62 @@
+use pallet_evm::{ExitError, PrecompileFailure, PrecompileHandle, PrecompileResult};
+
+use crate::precompiles::{
+    contract_to_origin, get_method_id, get_pubkey, get_slice, parse_netuid,
+    try_dispatch_runtime_call,
+};
+use sp_runtime::AccountId32;
+use sp_std::vec;
+
+use crate::{Runtime, RuntimeCall};
+pub const NEURON_PRECOMPILE_INDEX: u64 = 2052;
+
+// ss58 public key i.e., the contract sends funds it received to the destination address from the
+// method parameter.
+const CONTRACT_ADDRESS_SS58: [u8; 32] = [
+    0xbc, 0x46, 0x35, 0x79, 0xbc, 0x99, 0xf9, 0xee, 0x7c, 0x59, 0xed, 0xee, 0x20, 0x61, 0xa3, 0x09,
+    0xd2, 0x1e, 0x68, 0xd5, 0x39, 0xb6, 0x40, 0xec, 0x66, 0x46, 0x90, 0x30, 0xab, 0x74, 0xc1, 0xdb,
+];
+pub struct NeuronPrecompile;
+
+impl NeuronPrecompile {
+    pub fn execute(handle: &mut impl PrecompileHandle) -> PrecompileResult {
+        let txdata = handle.input();
+        let method_id = get_slice(txdata, 0, 4)?;
+        let method_input = txdata
+            .get(4..)
+            .map_or_else(vec::Vec::new, |slice| slice.to_vec()); // Avoiding borrowing conflicts
+
+        match method_id {
+            id if id == get_method_id("burnedRegister(uint16,bytes32)") => {
+                Self::burned_register(handle, &method_input)
+            }
+
+            _ => Err(PrecompileFailure::Error {
+                exit_status: ExitError::InvalidRange,
+            }),
+        }
+    }
+
+    pub fn burned_register(handle: &mut impl PrecompileHandle, data: &[u8]) -> PrecompileResult {
+        let (netuid, hotkey) = Self::parse_netuid_hotkey_parameter(data)?;
+        let call =
+            RuntimeCall::SubtensorModule(pallet_subtensor::Call::<Runtime>::burned_register {
+                netuid,
+                hotkey,
+            });
+        try_dispatch_runtime_call(handle, call, contract_to_origin(&CONTRACT_ADDRESS_SS58)?)
+    }
+
+    fn parse_netuid_hotkey_parameter(data: &[u8]) -> Result<(u16, AccountId32), PrecompileFailure> {
+        if data.len() < 64 {
+            return Err(PrecompileFailure::Error {
+                exit_status: ExitError::InvalidRange,
+            });
+        }
+        let netuid = parse_netuid(data, 30)?;
+
+        let (hotkey, _) = get_pubkey(get_slice(data, 32, 64)?)?;
+
+        Ok((netuid, hotkey))
+    }
+}

runtime/src/precompiles/solidity/neuron.abi

@@ -0,0 +1,20 @@
+[
+    {
+        "inputs": [
+            {
+                "internalType": "uint16",
+                "name": "netuid",
+                "type": "uint16"
+            },
+            {
+                "internalType": "bytes32",
+                "name": "hotkey",
+                "type": "bytes32"
+            }
+        ],
+        "name": "burnedRegister",
+        "outputs": [],
+        "stateMutability": "payable",
+        "type": "function"
+    }
+]

runtime/src/precompiles/solidity/neuron.sol

@@ -0,0 +1,14 @@
+pragma solidity ^0.8.0;
+
+address constant INeuron_ADDRESS = 0x0000000000000000000000000000000000000804;
+
+interface INeuron {
+    /**
+     * @dev Registers a neuron by calling `do_burned_registration` internally with the origin set to the ss58 mirror of the H160 address.
+     * This allows the H160 to further call neuron-related methods and receive emissions.
+     *
+     * @param netuid The subnet to register the neuron to (uint16).
+     * @param hotkey The hotkey public key (32 bytes).
+     */
+    function burnedRegister(uint16 netuid, bytes32 hotkey) external payable;
+}