Merge pull request #1184 from opentensor/fix/evm-gas-estimation

Fix gas estimation issues

Author: sam0x17

Cargo.lock

@@ -180,9 +180,10 @@ fc-consensus = { git = "https://github.com/opentensor/frontier", rev = "635bdac8
 fp-consensus = { git = "https://github.com/opentensor/frontier", rev = "635bdac882", default-features = false }
 fp-dynamic-fee = { git = "https://github.com/opentensor/frontier", rev = "635bdac882", default-features = false }
 fc-api = { git = "https://github.com/opentensor/frontier", rev = "635bdac882", default-features = false }
-fc-rpc = { git = "https://github.com/opentensor/frontier", rev = "635bdac882", default-features = false }
+fc-rpc = { git = "https://github.com/opentensor/frontier", rev = "635bdac882", default-features = false, features = ["rpc-binary-search-estimate"]}
 fc-rpc-core = { git = "https://github.com/opentensor/frontier", rev = "635bdac882", default-features = false }
 fc-mapping-sync = { git = "https://github.com/opentensor/frontier", rev = "635bdac882", default-features = false }
+precompile-utils = { git = "https://github.com/opentensor/frontier", rev = "635bdac882", default-features = false }
 
 # Frontier FRAME
 pallet-base-fee = { git = "https://github.com/opentensor/frontier", rev = "635bdac882", default-features = false }

Cargo.toml

@@ -77,6 +77,17 @@ fn localnet_genesis(
             get_account_id_from_seed::<sr25519::Public>("Ferdie"),
             2000000000000u128,
         ),
+        // ETH
+        (
+            // Alith - 0xf24FF3a9CF04c71Dbc94D0b566f7A27B94566cac
+            AccountId::from_str("5Fghzk1AJt88PeFEzuRfXzbPchiBbsVGTTXcdx599VdZzkTA").unwrap(),
+            2000000000000u128,
+        ),
+        (
+            // Baltathar - 0x3Cd0A705a2DC65e5b1E1205896BaA2be8A07c6e0
+            AccountId::from_str("5GeqNhKWj1KG78VHzbmo3ZjZgUTrCuWeamdgiA114XHGdaEr").unwrap(),
+            2000000000000u128,
+        ),
     ];
 
     // Check if the environment variable is set

node/src/chain_spec/localnet.rs

@@ -98,6 +98,7 @@ pallet-commitments = { default-features = false, path = "../pallets/commitments"
 fp-evm = { workspace = true }
 fp-rpc = { workspace = true }
 fp-self-contained = { workspace = true }
+precompile-utils = { workspace = true }
 
 # Frontier FRAME
 pallet-base-fee = { workspace = true }
@@ -191,6 +192,7 @@ std = [
 	"fp-evm/std",
 	"fp-rpc/std",
 	"fp-self-contained/std",
+	"precompile-utils/std",
 	# Frontier FRAME
 	"pallet-base-fee/std",
 	"pallet-dynamic-fee/std",

runtime/Cargo.toml

@@ -3,71 +3,75 @@ use pallet_evm::{
     BalanceConverter, ExitError, ExitSucceed, PrecompileFailure, PrecompileHandle,
     PrecompileOutput, PrecompileResult,
 };
+use precompile_utils::prelude::RuntimeHelper;
 use sp_core::U256;
-use sp_runtime::traits::{Dispatchable, UniqueSaturatedInto};
+use sp_runtime::traits::UniqueSaturatedInto;
 use sp_std::vec;
 
-use crate::{Runtime, RuntimeCall};
-
 use crate::precompiles::{bytes_to_account_id, get_method_id, get_slice};
+use crate::{Runtime, RuntimeCall};
 
 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] = [
+    0x07, 0xec, 0x71, 0x2a, 0x5d, 0x38, 0x43, 0x4d, 0xdd, 0x03, 0x3f, 0x8f, 0x02, 0x4e, 0xcd, 0xfc,
+    0x4b, 0xb5, 0x95, 0x1c, 0x13, 0xc3, 0x08, 0x5c, 0x39, 0x9c, 0x8a, 0x5f, 0x62, 0x93, 0x70, 0x5d,
+];
+
 pub struct BalanceTransferPrecompile;
 
 impl BalanceTransferPrecompile {
     pub fn execute(handle: &mut impl PrecompileHandle) -> PrecompileResult {
         let txdata = handle.input();
 
         // Match method ID: keccak256("transfer(bytes32)")
-        let method: &[u8] = get_slice(txdata, 0, 4)?;
-        if get_method_id("transfer(bytes32)") == method {
-            // Forward all received value to the destination address
-            let amount: U256 = handle.context().apparent_value;
+        let method = get_slice(txdata, 0, 4)?;
+        if get_method_id("transfer(bytes32)") != method {
+            return Ok(PrecompileOutput {
+                exit_status: ExitSucceed::Returned,
+                output: vec![],
+            });
+        }
 
-            // Use BalanceConverter to convert EVM amount to Substrate balance
-            let amount_sub =
-                <Runtime as pallet_evm::Config>::BalanceConverter::into_substrate_balance(amount)
-                    .ok_or(ExitError::OutOfFund)?;
+        // Forward all received value to the destination address
+        let amount: U256 = handle.context().apparent_value;
 
-            if amount_sub.is_zero() {
-                return Ok(PrecompileOutput {
-                    exit_status: ExitSucceed::Returned,
-                    output: vec![],
-                });
-            }
+        // Use BalanceConverter to convert EVM amount to Substrate balance
+        let amount_sub =
+            <Runtime as pallet_evm::Config>::BalanceConverter::into_substrate_balance(amount)
+                .ok_or(ExitError::OutOfFund)?;
 
-            // 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 ADDRESS_BYTES_SRC: [u8; 32] = [
-                0x07, 0xec, 0x71, 0x2a, 0x5d, 0x38, 0x43, 0x4d, 0xdd, 0x03, 0x3f, 0x8f, 0x02, 0x4e,
-                0xcd, 0xfc, 0x4b, 0xb5, 0x95, 0x1c, 0x13, 0xc3, 0x08, 0x5c, 0x39, 0x9c, 0x8a, 0x5f,
-                0x62, 0x93, 0x70, 0x5d,
-            ];
-            let address_bytes_dst: &[u8] = get_slice(txdata, 4, 36)?;
-            let account_id_src = bytes_to_account_id(&ADDRESS_BYTES_SRC)?;
-            let account_id_dst = bytes_to_account_id(address_bytes_dst)?;
+        if amount_sub.is_zero() {
+            return Ok(PrecompileOutput {
+                exit_status: ExitSucceed::Returned,
+                output: vec![],
+            });
+        }
 
-            let call =
-                RuntimeCall::Balances(pallet_balances::Call::<Runtime>::transfer_allow_death {
-                    dest: account_id_dst.into(),
-                    value: amount_sub.unique_saturated_into(),
-                });
+        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)?;
 
-            // Dispatch the call
-            let result = call.dispatch(RawOrigin::Signed(account_id_src).into());
-            if result.is_err() {
-                return Err(PrecompileFailure::Error {
-                    exit_status: ExitError::OutOfFund,
-                });
-            }
-        }
+        let call = RuntimeCall::Balances(pallet_balances::Call::<Runtime>::transfer_allow_death {
+            dest: account_id_dst.into(),
+            value: amount_sub.unique_saturated_into(),
+        });
 
-        Ok(PrecompileOutput {
+        // Dispatch the call
+        RuntimeHelper::<Runtime>::try_dispatch(
+            handle,
+            RawOrigin::Signed(account_id_src).into(),
+            call,
+        )
+        .map(|_| PrecompileOutput {
             exit_status: ExitSucceed::Returned,
             output: vec![],
         })
+        .map_err(|_| PrecompileFailure::Error {
+            exit_status: ExitError::OutOfFund,
+        })
     }
 }

runtime/src/precompiles/balance_transfer.rs

@@ -26,23 +26,22 @@
 //
 
 use frame_system::RawOrigin;
-use pallet_evm::{AddressMapping, BalanceConverter, HashedAddressMapping};
 use pallet_evm::{
-    ExitError, ExitSucceed, PrecompileFailure, PrecompileHandle, PrecompileOutput, PrecompileResult,
+    AddressMapping, BalanceConverter, ExitError, ExitSucceed, HashedAddressMapping,
+    PrecompileFailure, PrecompileHandle, PrecompileOutput, PrecompileResult,
 };
+use precompile_utils::prelude::RuntimeHelper;
 use sp_core::crypto::Ss58Codec;
 use sp_core::U256;
-use sp_runtime::traits::Dispatchable;
-use sp_runtime::traits::{BlakeTwo256, StaticLookup, UniqueSaturatedInto};
+use sp_runtime::traits::{BlakeTwo256, Dispatchable, StaticLookup, UniqueSaturatedInto};
 use sp_runtime::AccountId32;
+use sp_std::vec;
 
 use crate::{
     precompiles::{get_method_id, get_slice},
-    ProxyType,
+    ProxyType, Runtime, RuntimeCall,
 };
-use sp_std::vec;
 
-use crate::{Runtime, RuntimeCall};
 pub const STAKING_PRECOMPILE_INDEX: u64 = 2049;
 
 pub struct StakingPrecompile;
@@ -209,24 +208,28 @@ impl StakingPrecompile {
             );
 
         // Transfer the amount back to the caller before executing the staking operation
-        // let caller = handle.context().caller;
         let amount = handle.context().apparent_value;
 
         if !amount.is_zero() {
             Self::transfer_back_to_caller(&account_id, amount)?;
         }
 
-        let result = call.dispatch(RawOrigin::Signed(account_id.clone()).into());
-        match &result {
-            Ok(post_info) => log::info!("Dispatch succeeded. Post info: {:?}", post_info),
-            Err(dispatch_error) => log::error!("Dispatch failed. Error: {:?}", dispatch_error),
-        }
-        match result {
-            Ok(_) => Ok(PrecompileOutput {
-                exit_status: ExitSucceed::Returned,
-                output: vec![],
-            }),
-            Err(_) => {
+        match RuntimeHelper::<Runtime>::try_dispatch(
+            handle,
+            RawOrigin::Signed(account_id.clone()).into(),
+            call,
+        ) {
+            Ok(post_info) => {
+                log::info!("Dispatch succeeded. Post info: {:?}", post_info);
+
+                Ok(PrecompileOutput {
+                    exit_status: ExitSucceed::Returned,
+                    output: vec![],
+                })
+            }
+
+            Err(dispatch_error) => {
+                log::error!("Dispatch failed. Error: {:?}", dispatch_error);
                 log::warn!("Returning error PrecompileFailure::Error");
                 Err(PrecompileFailure::Error {
                     exit_status: ExitError::Other("Subtensor call failed".into()),