Clean up precompiles crate

Author: ales-otf

precompiles/src/balance_transfer.rs

@@ -6,7 +6,8 @@ use precompile_utils::EvmResult;
 use sp_core::{H256, U256};
 use sp_runtime::traits::{Dispatchable, StaticLookup, UniqueSaturatedInto};
 
-use crate::{PrecompileExt, PrecompileHandleExt, contract_to_origin, parse_pubkey};
+use crate::parser::{contract_to_origin, parse_pubkey};
+use crate::{PrecompileExt, PrecompileHandleExt};
 
 pub(crate) struct BalanceTransferPrecompile<R>(PhantomData<R>);
 

precompiles/src/ed25519.rs

@@ -5,7 +5,8 @@ use alloc::vec::Vec;
 use ed25519_dalek::{Signature, Verifier, VerifyingKey};
 use fp_evm::{ExitError, ExitSucceed, LinearCostPrecompile, PrecompileFailure};
 
-use crate::{PrecompileExt, parse_slice};
+use crate::PrecompileExt;
+use crate::parser::parse_slice;
 
 pub(crate) struct Ed25519Verify;
 

precompiles/src/lib.rs

@@ -21,7 +21,6 @@ use sp_runtime::traits::StaticLookup;
 use subtensor_runtime_common::ProxyType;
 
 use pallet_admin_utils::{PrecompileEnable, PrecompileEnum};
-use sp_std::vec;
 
 use crate::balance_transfer::*;
 use crate::ed25519::*;
@@ -34,6 +33,7 @@ mod balance_transfer;
 mod ed25519;
 mod metagraph;
 mod neuron;
+mod parser;
 mod staking;
 mod subnet;
 
@@ -202,48 +202,6 @@ fn hash(a: u64) -> H160 {
     H160::from_low_u64_be(a)
 }
 
-/// Takes a slice from bytes with PrecompileFailure as Error
-fn parse_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,
-        })
-    }
-}
-
-fn parse_pubkey<A: From<[u8; 32]>>(data: &[u8]) -> Result<(A, vec::Vec<u8>), PrecompileFailure> {
-    let mut pubkey = [0u8; 32];
-    pubkey.copy_from_slice(parse_slice(data, 0, 32)?);
-
-    Ok((
-        pubkey.into(),
-        data.get(32..)
-            .map_or_else(vec::Vec::new, |slice| slice.to_vec()),
-    ))
-}
-
-fn contract_to_origin<A: From<[u8; 32]>>(
-    contract: &[u8; 32],
-) -> Result<RawOrigin<A>, PrecompileFailure> {
-    let (account_id, _) = parse_pubkey::<A>(contract)?;
-    Ok(RawOrigin::Signed(account_id))
-}
-
-fn try_u16_from_u256(value: U256) -> Result<u16, PrecompileFailure> {
-    value.try_into().map_err(|_| PrecompileFailure::Error {
-        exit_status: ExitError::Other("the value is outside of u16 bounds".into()),
-    })
-}
-
 trait PrecompileHandleExt: PrecompileHandle {
     fn caller_account_id<R>(&self) -> R::AccountId
     where

precompiles/src/neuron.rs

@@ -8,7 +8,8 @@ use sp_core::H256;
 use sp_runtime::traits::Dispatchable;
 use sp_std::vec::Vec;
 
-use crate::{PrecompileExt, PrecompileHandleExt, parse_pubkey};
+use crate::parser::parse_pubkey;
+use crate::{PrecompileExt, PrecompileHandleExt};
 
 pub struct NeuronPrecompile<R>(PhantomData<R>);
 

precompiles/src/parser.rs

@@ -0,0 +1,50 @@
+extern crate alloc;
+
+use frame_system::RawOrigin;
+use pallet_evm::{ExitError, PrecompileFailure};
+use sp_core::U256;
+use sp_std::vec;
+
+/// Takes a slice from bytes with PrecompileFailure as Error
+pub(crate) fn parse_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(crate) fn parse_pubkey<A: From<[u8; 32]>>(
+    data: &[u8],
+) -> Result<(A, vec::Vec<u8>), PrecompileFailure> {
+    let mut pubkey = [0u8; 32];
+    pubkey.copy_from_slice(parse_slice(data, 0, 32)?);
+
+    Ok((
+        pubkey.into(),
+        data.get(32..)
+            .map_or_else(vec::Vec::new, |slice| slice.to_vec()),
+    ))
+}
+
+pub(crate) fn contract_to_origin<A: From<[u8; 32]>>(
+    contract: &[u8; 32],
+) -> Result<RawOrigin<A>, PrecompileFailure> {
+    let (account_id, _) = parse_pubkey::<A>(contract)?;
+    Ok(RawOrigin::Signed(account_id))
+}
+
+pub(crate) fn try_u16_from_u256(value: U256) -> Result<u16, PrecompileFailure> {
+    value.try_into().map_err(|_| PrecompileFailure::Error {
+        exit_status: ExitError::Other("the value is outside of u16 bounds".into()),
+    })
+}

precompiles/src/staking.rs

@@ -37,7 +37,8 @@ use sp_core::{H256, U256};
 use sp_runtime::traits::{Dispatchable, StaticLookup, UniqueSaturatedInto};
 use subtensor_runtime_common::ProxyType;
 
-use crate::{PrecompileExt, PrecompileHandleExt, parse_pubkey, try_u16_from_u256};
+use crate::parser::{parse_pubkey, try_u16_from_u256};
+use crate::{PrecompileExt, PrecompileHandleExt};
 
 pub(crate) struct StakingPrecompile<R>(PhantomData<R>);
 

precompiles/src/subnet.rs

@@ -8,7 +8,8 @@ use precompile_utils::{EvmResult, prelude::BoundedString};
 use sp_core::H256;
 use sp_runtime::traits::Dispatchable;
 
-use crate::{PrecompileExt, PrecompileHandleExt, parse_pubkey};
+use crate::parser::parse_pubkey;
+use crate::{PrecompileExt, PrecompileHandleExt};
 
 pub struct SubnetPrecompile<R>(PhantomData<R>);