[MOON-2092] Implement call state override for eth_call

client/rpc-core/src/types/call_request.rs

@@ -18,8 +18,9 @@
 
 use crate::types::Bytes;
 use ethereum::AccessListItem;
-use ethereum_types::{H160, U256};
+use ethereum_types::{H160, H256, U256};
 use serde::Deserialize;
+use std::collections::BTreeMap;
 
 /// Call request
 #[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize)]
@@ -49,4 +50,26 @@ pub struct CallRequest {
 	/// EIP-2718 type
 	#[serde(rename = "type")]
 	pub transaction_type: Option<U256>,
+	/// Call state override
+	#[serde(rename = "stateOverride")]
+	pub state_override: Option<CallStateOverride>,
+}
+
+// State override
+#[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize)]
+#[serde(deny_unknown_fields)]
+#[serde(rename_all = "camelCase")]
+pub struct CallStateOverride {
+	/// Fake balance to set for the account before executing the call.
+	pub balance: Option<U256>,
+	/// Fake nonce to set for the account before executing the call.
+	pub nonce: Option<U256>,
+	/// Fake EVM bytecode to inject into the account before executing the call.
+	pub code: Option<Bytes>,
+	/// Fake key-value mapping to override all slots in the account storage before
+	/// executing the call.
+	pub state: Option<BTreeMap<H256, H256>>,
+	/// Fake key-value mapping to override individual slots in the account storage before
+	/// executing the call.
+	pub state_diff: Option<BTreeMap<H256, H256>>,
 }

client/rpc-core/src/types/mod.rs

@@ -40,7 +40,7 @@ pub use self::{
 	block::{Block, BlockTransactions, Header, Rich, RichBlock, RichHeader},
 	block_number::BlockNumber,
 	bytes::Bytes,
-	call_request::CallRequest,
+	call_request::{CallRequest, CallStateOverride},
 	fee::{FeeHistory, FeeHistoryCache, FeeHistoryCacheItem, FeeHistoryCacheLimit},
 	filter::{
 		Filter, FilterAddress, FilterChanges, FilterPool, FilterPoolItem, FilterType,

client/rpc/Cargo.toml

@@ -43,12 +43,14 @@ sp-core = { workspace = true }
 sp-io = { workspace = true }
 sp-runtime = { workspace = true }
 sp-storage = { workspace = true }
+sp-state-machine = { workspace = true }
 # Frontier
 fc-db = { workspace = true }
 fc-rpc-core = { workspace = true }
 fp-ethereum = { workspace = true, features = ["std"] }
 fp-rpc = { workspace = true, features = ["std"] }
 fp-storage = { workspace = true, features = ["std"] }
+fp-evm = { workspace = true }
 
 [dev-dependencies]
 tempfile = "3.3.0"

client/rpc/src/eth/execute.rs

@@ -25,9 +25,10 @@ use jsonrpsee::core::RpcResult as Result;
 use sc_client_api::backend::{Backend, StateBackend, StorageProvider};
 use sc_network_common::ExHashT;
 use sc_transaction_pool::ChainApi;
-use sp_api::{ApiExt, ProvideRuntimeApi};
+use sp_api::{ApiExt, CallApiAt, ProvideRuntimeApi};
 use sp_block_builder::BlockBuilder as BlockBuilderApi;
 use sp_blockchain::HeaderBackend;
+use sp_io::hashing::{blake2_128, twox_128};
 use sp_runtime::{
 	generic::BlockId,
 	traits::{BlakeTwo256, Block as BlockT},
@@ -36,6 +37,7 @@ use sp_runtime::{
 // Frontier
 use fc_rpc_core::types::*;
 use fp_rpc::EthereumRuntimeRPCApi;
+use fp_storage::{EVM_ACCOUNT_CODES, PALLET_EVM};
 
 use crate::{
 	eth::{pending_runtime_api, Eth},
@@ -67,7 +69,7 @@ impl<B, C, P, CT, BE, H: ExHashT, A: ChainApi, EGA> Eth<B, C, P, CT, BE, H, A, E
 where
 	B: BlockT<Hash = H256> + Send + Sync + 'static,
 	C: ProvideRuntimeApi<B> + StorageProvider<B, BE>,
-	C: HeaderBackend<B> + Send + Sync + 'static,
+	C: HeaderBackend<B> + CallApiAt<B> + Send + Sync + 'static,
 	C::Api: BlockBuilderApi<B> + EthereumRuntimeRPCApi<B>,
 	BE: Backend<B> + 'static,
 	BE::State: StateBackend<BlakeTwo256>,
@@ -86,6 +88,7 @@ where
 			data,
 			nonce,
 			access_list,
+			state_override,
 			..
 		} = request;
 
@@ -161,6 +164,8 @@ where
 			},
 		};
 
+		log::info!("VER {api_version}");
+
 		let data = data.map(|d| d.0).unwrap_or_default();
 		match to {
 			Some(to) => {
@@ -205,29 +210,104 @@ where
 					Ok(Bytes(info.value))
 				} else if api_version == 4 {
 					// Post-london + access list support
-					let access_list = access_list.unwrap_or_default();
-					let info = api
-						.call(
-							&id,
-							from.unwrap_or_default(),
-							to,
-							data,
-							value.unwrap_or_default(),
-							gas_limit,
-							max_fee_per_gas,
-							max_priority_fee_per_gas,
-							nonce,
-							false,
-							Some(
-								access_list
-									.into_iter()
-									.map(|item| (item.address, item.storage_keys))
-									.collect(),
-							),
-						)
+					let encoded_params = sp_api::Encode::encode(&(
+						&from.unwrap_or_default(),
+						&to,
+						&data,
+						&value.unwrap_or_default(),
+						&gas_limit,
+						&max_fee_per_gas,
+						&max_priority_fee_per_gas,
+						&nonce,
+						&false,
+						&Some(
+							access_list
+								.unwrap_or_default()
+								.into_iter()
+								.map(|item| (item.address, item.storage_keys))
+								.collect::<Vec<(sp_core::H160, Vec<H256>)>>(),
+						),
+					));
+
+					// set custom storage override
+					let mut overlayed_changes = sp_api::OverlayedChanges::default();
+					if let Some(state_override) = state_override {
+						let address = from.unwrap_or_default();
+						if let Some(runtime_state_override) = self.runtime_state_override.as_ref() {
+							let hash =
+								self.client.expect_block_hash_from_id(&id).map_err(|err| {
+									internal_err(format!("failed retrieving block hash: {:?}", err))
+								})?;
+
+							runtime_state_override.set_overlayed_changes(
+								self.client.as_ref(),
+								&mut overlayed_changes,
+								hash,
+								api_version,
+								address,
+								state_override.balance,
+								state_override.nonce,
+							);
+						}
+
+						if let Some(code) = &state_override.code {
+							let mut key = [twox_128(PALLET_EVM), twox_128(EVM_ACCOUNT_CODES)]
+								.concat()
+								.to_vec();
+							key.extend(blake2_128(address.as_bytes()));
+							key.extend(address.as_bytes());
+							overlayed_changes.set_storage(key, Some(code.clone().into_vec()));
+						}
+
+						// Prioritize `state_diff` over `state`
+						if let Some(state_diff) = &state_override.state_diff {
+							for (k, v) in state_diff {
+								overlayed_changes.set_storage(
+									k.as_bytes().to_owned(),
+									Some(v.as_bytes().to_owned()),
+								);
+							}
+						} else if let Some(state) = &state_override.state {
+							for (k, v) in state {
+								overlayed_changes.set_storage(
+									k.as_bytes().to_owned(),
+									Some(v.as_bytes().to_owned()),
+								);
+							}
+						}
+					}
+
+					let storage_transaction_cache = std::cell::RefCell::<
+						sp_api::StorageTransactionCache<B, C::StateBackend>,
+					>::default();
+					let params = sp_api::CallApiAtParams {
+						at: &id,
+						function: "EthereumRuntimeRPCApi_call",
+						arguments: encoded_params,
+						overlayed_changes: &std::cell::RefCell::new(overlayed_changes),
+						storage_transaction_cache: &storage_transaction_cache,
+						context: sp_api::ExecutionContext::OffchainCall(None),
+						recorder: &None,
+					};
+					let info = self
+						.client
+						.call_api_at(params)
+						.and_then(|r| {
+							std::result::Result::map_err(
+									<std::result::Result<
+										fp_evm::CallInfo,
+										sp_runtime::DispatchError,
+									> as sp_api::Decode>::decode(&mut &r[..]),
+									|error| sp_api::ApiError::FailedToDecodeReturnValue {
+										function: "EthereumRuntimeRPCApi_call",
+										error,
+									},
+								)
+						})
 						.map_err(|err| internal_err(format!("runtime error: {:?}", err)))?
 						.map_err(|err| internal_err(format!("execution fatal: {:?}", err)))?;
 
+					log::info!("2 {:?}", info);
 					error_on_execution_failure(&info.exit_reason, &info.value)?;
 					Ok(Bytes(info.value))
 				} else {

client/rpc/src/eth/mod.rs

@@ -39,7 +39,7 @@ use sc_network::NetworkService;
 use sc_network_common::ExHashT;
 use sc_transaction_pool::{ChainApi, Pool};
 use sc_transaction_pool_api::{InPoolTransaction, TransactionPool};
-use sp_api::{Core, HeaderT, ProvideRuntimeApi};
+use sp_api::{CallApiAt, Core, HeaderT, ProvideRuntimeApi};
 use sp_block_builder::BlockBuilder as BlockBuilderApi;
 use sp_blockchain::HeaderBackend;
 use sp_core::hashing::keccak_256;
@@ -49,7 +49,10 @@ use sp_runtime::{
 };
 // Frontier
 use fc_rpc_core::{types::*, EthApiServer};
-use fp_rpc::{ConvertTransactionRuntimeApi, EthereumRuntimeRPCApi, TransactionStatus};
+use fp_rpc::{
+	ConvertTransactionRuntimeApi, EthereumRuntimeRPCApi, EthereumRuntimeStorageOverride,
+	TransactionStatus,
+};
 
 use crate::{internal_err, overrides::OverrideHandle, public_key, signer::EthSigner};
 
@@ -76,6 +79,7 @@ pub struct Eth<B: BlockT, C, P, CT, BE, H: ExHashT, A: ChainApi, EGA = ()> {
 	/// When using eth_call/eth_estimateGas, the maximum allowed gas limit will be
 	/// block.gas_limit * execute_gas_limit_multiplier
 	execute_gas_limit_multiplier: u64,
+	runtime_state_override: Option<Arc<dyn EthereumRuntimeStorageOverride<B, C>>>,
 	_marker: PhantomData<(B, BE, EGA)>,
 }
 
@@ -94,6 +98,7 @@ impl<B: BlockT, C, P, CT, BE, H: ExHashT, A: ChainApi> Eth<B, C, P, CT, BE, H, A
 		fee_history_cache: FeeHistoryCache,
 		fee_history_cache_limit: FeeHistoryCacheLimit,
 		execute_gas_limit_multiplier: u64,
+		runtime_state_override: Option<Arc<dyn EthereumRuntimeStorageOverride<B, C>>>,
 	) -> Self {
 		Self {
 			client,
@@ -109,6 +114,7 @@ impl<B: BlockT, C, P, CT, BE, H: ExHashT, A: ChainApi> Eth<B, C, P, CT, BE, H, A
 			fee_history_cache,
 			fee_history_cache_limit,
 			execute_gas_limit_multiplier,
+			runtime_state_override,
 			_marker: PhantomData,
 		}
 	}
@@ -132,6 +138,7 @@ impl<B: BlockT, C, P, CT, BE, H: ExHashT, A: ChainApi, EGA> Eth<B, C, P, CT, BE,
 			fee_history_cache,
 			fee_history_cache_limit,
 			execute_gas_limit_multiplier,
+			runtime_state_override,
 			_marker: _,
 		} = self;
 
@@ -149,6 +156,7 @@ impl<B: BlockT, C, P, CT, BE, H: ExHashT, A: ChainApi, EGA> Eth<B, C, P, CT, BE,
 			fee_history_cache,
 			fee_history_cache_limit,
 			execute_gas_limit_multiplier,
+			runtime_state_override,
 			_marker: PhantomData,
 		}
 	}
@@ -159,7 +167,7 @@ impl<B, C, P, CT, BE, H: ExHashT, A, EGA> EthApiServer for Eth<B, C, P, CT, BE,
 where
 	B: BlockT<Hash = H256> + Send + Sync + 'static,
 	C: ProvideRuntimeApi<B> + StorageProvider<B, BE>,
-	C: HeaderBackend<B> + Send + Sync + 'static,
+	C: HeaderBackend<B> + CallApiAt<B> + Send + Sync + 'static,
 	C::Api: BlockBuilderApi<B> + ConvertTransactionRuntimeApi<B> + EthereumRuntimeRPCApi<B>,
 	P: TransactionPool<Block = B> + Send + Sync + 'static,
 	CT: fp_rpc::ConvertTransaction<<B as BlockT>::Extrinsic> + Send + Sync + 'static,
@@ -290,6 +298,7 @@ where
 	// ########################################################################
 
 	fn call(&self, request: CallRequest, number: Option<BlockNumber>) -> Result<Bytes> {
+		log::info!("CALL");
 		self.call(request, number)
 	}
 
@@ -508,7 +517,7 @@ fn pending_runtime_api<'a, B: BlockT, C, BE, A: ChainApi>(
 where
 	B: BlockT<Hash = H256> + Send + Sync + 'static,
 	C: ProvideRuntimeApi<B> + StorageProvider<B, BE>,
-	C: HeaderBackend<B> + Send + Sync + 'static,
+	C: HeaderBackend<B> + sp_api::CallApiAt<B> + Send + Sync + 'static,
 	C::Api: BlockBuilderApi<B> + EthereumRuntimeRPCApi<B>,
 	BE: Backend<B> + 'static,
 	BE::State: StateBackend<BlakeTwo256>,

client/rpc/src/eth/state.rs

@@ -44,7 +44,7 @@ impl<B, C, P, CT, BE, H: ExHashT, A: ChainApi, EGA> Eth<B, C, P, CT, BE, H, A, E
 where
 	B: BlockT<Hash = H256> + Send + Sync + 'static,
 	C: ProvideRuntimeApi<B> + StorageProvider<B, BE>,
-	C: HeaderBackend<B> + Send + Sync + 'static,
+	C: HeaderBackend<B> + sp_api::CallApiAt<B> + Send + Sync + 'static,
 	C::Api: BlockBuilderApi<B> + EthereumRuntimeRPCApi<B>,
 	BE: Backend<B> + 'static,
 	BE::State: StateBackend<BlakeTwo256>,

client/rpc/src/eth/submit.rs

@@ -45,7 +45,7 @@ impl<B, C, P, CT, BE, H: ExHashT, A: ChainApi, EGA> Eth<B, C, P, CT, BE, H, A, E
 where
 	B: BlockT<Hash = H256> + Send + Sync + 'static,
 	C: ProvideRuntimeApi<B> + StorageProvider<B, BE>,
-	C: HeaderBackend<B> + Send + Sync + 'static,
+	C: HeaderBackend<B> + sp_api::CallApiAt<B> + Send + Sync + 'static,
 	C::Api: BlockBuilderApi<B> + ConvertTransactionRuntimeApi<B> + EthereumRuntimeRPCApi<B>,
 	BE: Backend<B> + 'static,
 	BE::State: StateBackend<BlakeTwo256>,