pallet_revive: Add dry-run timestamp override support

.github/workflows/tests-evm.yml

@@ -112,7 +112,7 @@ jobs:
         uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           repository: paritytech/evm-test-suite
-          ref: 460b2c9aa3a3019d3508bb5a34a2498ea86035ff
+          ref: 372e9b48d375a63297d6e553a70a89c4e9dfa14e
           path: evm-test-suite
 
       - uses: denoland/setup-deno@v1

prdoc/pr_10191.prdoc

@@ -0,0 +1,30 @@
+title: 'pallet_revive: Add dry-run timestamp override support'
+doc:
+- audience: Runtime User
+  description: |-
+    # Description
+
+    This PR updates `pallet-revive` to **support overriding the block timestamp during dry-run calls**.
+    The dry-run execution now uses the following configuration for `eth_estimateGas` and `eth_call` when the block tag is `pending`:
+
+    ```text
+    block.timestamp = max(rpc_timestamp, latest_block.timestamp + 1)
+    block.number = latest_block.number + 1
+    ```
+
+    Fixes [#153](https://github.com/paritytech/contract-issues/issues/153), [#205](https://github.com/paritytech/contract-issues/issues/205)
+
+    ## Integration
+
+    Downstream projects using the `ReviveApi::eth_transact` runtime API should either provide a `timestamp` or pass `None`.
+
+    ## Review Notes
+    - Added dry run timestamp to `ExecConfig`.
+    - Added a new parameter to `ReviveApi::eth_transact` for passing the current RPC timestamp.
+    - `eth_estimateGas` defaults to the `pending` block tag.
+    - `eth_estimateGas` and `eth_call` with `pending` block tag will dry run the transaction with the block timestamp set to `max(rpc_timestamp, latest_block.timestamp + 1)` and block number set to `latest_block.number + 1`.
+crates:
+- name: pallet-revive-eth-rpc
+  bump: major
+- name: pallet-revive
+  bump: major

substrate/frame/revive/rpc/Cargo.toml

@@ -41,6 +41,7 @@ sp-core = { workspace = true, default-features = true }
 sp-crypto-hashing = { workspace = true }
 sp-rpc = { workspace = true, default-features = true }
 sp-runtime = { workspace = true, default-features = true }
+sp-timestamp = { workspace = true }
 sp-weights = { workspace = true, default-features = true }
 sqlx = { workspace = true, features = ["macros", "runtime-tokio", "sqlite"] }
 subxt = { workspace = true, default-features = true, features = ["reconnecting-rpc-client"] }

substrate/frame/revive/rpc/src/client/runtime_api.rs

@@ -20,12 +20,17 @@ use crate::{
 	subxt_client::{self, SrcChainConfig},
 	ClientError,
 };
+use futures::TryFutureExt;
 use pallet_revive::{
-	evm::{Block as EthBlock, GenericTransaction, ReceiptGasInfo, Trace, H160, U256},
-	EthTransactInfo,
+	evm::{
+		Block as EthBlock, BlockNumberOrTagOrHash, BlockTag, GenericTransaction, ReceiptGasInfo,
+		Trace, H160, U256,
+	},
+	DryRunConfig, EthTransactInfo,
 };
 use sp_core::H256;
-use subxt::OnlineClient;
+use sp_timestamp::Timestamp;
+use subxt::{error::MetadataError, ext::subxt_rpcs::UserError, Error::Metadata, OnlineClient};
 
 const LOG_TARGET: &str = "eth-rpc::runtime_api";
 
@@ -65,9 +70,48 @@ impl RuntimeApi {
 	pub async fn dry_run(
 		&self,
 		tx: GenericTransaction,
+		block: BlockNumberOrTagOrHash,
 	) -> Result<EthTransactInfo<Balance>, ClientError> {
-		let payload = subxt_client::apis().revive_api().eth_transact(tx.into());
-		let result = self.0.call(payload).await?;
+		let timestamp_override = match block {
+			BlockNumberOrTagOrHash::BlockTag(BlockTag::Pending) =>
+				Some(Timestamp::current().as_millis()),
+			_ => None,
+		};
+
+		let payload = subxt_client::apis()
+			.revive_api()
+			.eth_transact_with_config(
+				tx.clone().into(),
+				DryRunConfig::new(timestamp_override).into(),
+			)
+			.unvalidated();
+
+		let result = self
+			.0
+			.call(payload)
+			.or_else(|err| async {
+				match err {
+					// This will be hit if subxt metadata (subxt uses the latest finalized block
+					// metadata when the eth-rpc starts) does not contain the new method
+					Metadata(MetadataError::RuntimeMethodNotFound(name)) => {
+						log::debug!(target: LOG_TARGET, "Method {name:?} not found falling back to eth_transact");
+						let payload = subxt_client::apis().revive_api().eth_transact(tx.into());
+						self.0.call(payload).await
+					},
+					// This will be hit if we are trying to hit a block where the runtime did not
+					// have this new runtime `eth_transact_with_config` defined
+					subxt::Error::Rpc(subxt::error::RpcError::ClientError(
+						subxt::ext::subxt_rpcs::Error::User(UserError { message, .. }),
+					)) if message.contains("eth_transact_with_config is not found") => {
+						log::debug!(target: LOG_TARGET, "{message:?} not found falling back to eth_transact");
+						let payload = subxt_client::apis().revive_api().eth_transact(tx.into());
+						self.0.call(payload).await
+					},
+					e => Err(e),
+				}
+			})
+			.await?;
+
 		match result {
 			Err(err) => {
 				log::debug!(target: LOG_TARGET, "Dry run failed {err:?}");

substrate/frame/revive/rpc/src/lib.rs

@@ -145,9 +145,10 @@ impl EthRpcServer for EthRpcServerImpl {
 		block: Option<BlockNumberOrTag>,
 	) -> RpcResult<U256> {
 		log::trace!(target: LOG_TARGET, "estimate_gas transaction={transaction:?} block={block:?}");
-		let hash = self.client.block_hash_for_tag(block.unwrap_or_default().into()).await?;
+		let block = block.unwrap_or_default();
+		let hash = self.client.block_hash_for_tag(block.clone().into()).await?;
 		let runtime_api = self.client.runtime_api(hash);
-		let dry_run = runtime_api.dry_run(transaction).await?;
+		let dry_run = runtime_api.dry_run(transaction, block.into()).await?;
 		log::trace!(target: LOG_TARGET, "estimate_gas result={dry_run:?}");
 		Ok(dry_run.eth_gas)
 	}
@@ -157,9 +158,10 @@ impl EthRpcServer for EthRpcServerImpl {
 		transaction: GenericTransaction,
 		block: Option<BlockNumberOrTagOrHash>,
 	) -> RpcResult<Bytes> {
-		let hash = self.client.block_hash_for_tag(block.unwrap_or_default()).await?;
+		let block = block.unwrap_or_default();
+		let hash = self.client.block_hash_for_tag(block.clone()).await?;
 		let runtime_api = self.client.runtime_api(hash);
-		let dry_run = runtime_api.dry_run(transaction).await?;
+		let dry_run = runtime_api.dry_run(transaction, block).await?;
 		Ok(dry_run.data.into())
 	}
 

substrate/frame/revive/rpc/src/subxt_client.rs

@@ -47,6 +47,10 @@ pub use subxt::config::PolkadotConfig as SrcChainConfig;
 		path = "pallet_revive::evm::api::rpc_types_gen::GenericTransaction",
 		with = "::subxt::utils::Static<::pallet_revive::evm::GenericTransaction>"
 	),
+	substitute_type(
+		path = "pallet_revive::evm::api::rpc_types::DryRunConfig<M>",
+		with = "::subxt::utils::Static<::pallet_revive::evm::DryRunConfig<M>>"
+	),
 	substitute_type(
 		path = "pallet_revive::primitives::EthTransactInfo<B>",
 		with = "::subxt::utils::Static<::pallet_revive::EthTransactInfo<B>>"

substrate/frame/revive/src/evm/api.rs

@@ -31,6 +31,8 @@ mod debug_rpc_types;
 pub use debug_rpc_types::*;
 
 mod rpc_types;
+pub use rpc_types::DryRunConfig;
+
 mod rpc_types_gen;
 pub use rpc_types_gen::*;
 

substrate/frame/revive/src/evm/api/rpc_types.rs

@@ -17,8 +17,29 @@
 //! Utility impl for the RPC types.
 use super::*;
 use alloc::vec::Vec;
+use codec::{Decode, Encode};
+use frame_support::DefaultNoBound;
+use scale_info::TypeInfo;
 use sp_core::{H160, U256};
 
+/// Configuration specific to a dry-run execution.
+#[derive(Debug, Encode, Decode, TypeInfo, Clone, DefaultNoBound)]
+pub struct DryRunConfig<Moment> {
+	/// Optional timestamp override for dry-run in pending block.
+	pub timestamp_override: Option<Moment>,
+	/// Used for future extensions without breaking encoding.
+	pub reserved: Option<()>,
+}
+impl<Moment> DryRunConfig<Moment> {
+	/// Create a new `DryRunConfig` with an optional timestamp override.
+	pub fn new(timestamp_override: Option<Moment>) -> Self {
+		Self {
+			timestamp_override,
+			reserved: None, // default value
+		}
+	}
+}
+
 impl From<BlockNumberOrTag> for BlockNumberOrTagOrHash {
 	fn from(b: BlockNumberOrTag) -> Self {
 		match b {

substrate/frame/revive/src/evm/runtime.rs

@@ -429,7 +429,8 @@ mod test {
 			let account = Account::default();
 			Self::fund_account(&account);
 
-			let dry_run = crate::Pallet::<Test>::dry_run_eth_transact(self.tx.clone());
+			let dry_run =
+				crate::Pallet::<Test>::dry_run_eth_transact(self.tx.clone(), Default::default());
 			self.tx.gas_price = Some(<Pallet<Test>>::evm_base_fee());
 
 			match dry_run {

substrate/frame/revive/src/exec.rs

@@ -38,7 +38,7 @@ use alloc::{
 	collections::{BTreeMap, BTreeSet},
 	vec::Vec,
 };
-use core::{fmt::Debug, marker::PhantomData, mem, ops::ControlFlow};
+use core::{cmp, fmt::Debug, marker::PhantomData, mem, ops::ControlFlow};
 use frame_support::{
 	crypto::ecdsa::ECDSAExt,
 	dispatch::DispatchResult,
@@ -951,12 +951,24 @@ where
 			return Ok(None);
 		};
 
+		let mut timestamp = T::Time::now();
+		let mut block_number = <frame_system::Pallet<T>>::block_number();
+		// if dry run with timestamp override is provided we simulate the run in a `pending` block
+		if let Some(timestamp_override) =
+			exec_config.is_dry_run.as_ref().and_then(|cfg| cfg.timestamp_override)
+		{
+			block_number = block_number.saturating_add(1u32.into());
+			// Delta is in milliseconds; increment timestamp by one second
+			let delta = 1000u32.into();
+			timestamp = cmp::max(timestamp.saturating_add(delta), timestamp_override);
+		}
+
 		let stack = Self {
 			origin,
 			gas_meter,
 			storage_meter,
-			timestamp: T::Time::now(),
-			block_number: <frame_system::Pallet<T>>::block_number(),
+			timestamp,
+			block_number,
 			first_frame,
 			frames: Default::default(),
 			transient_storage: TransientStorage::new(limits::TRANSIENT_STORAGE_BYTES),
@@ -965,7 +977,6 @@ where
 			contracts_to_be_destroyed: BTreeMap::new(),
 			_phantom: Default::default(),
 		};
-
 		Ok(Some((stack, executable)))
 	}
 
@@ -1324,7 +1335,7 @@ where
 					// When a dry-run simulates contract deployment, keep the execution result's
 					// data.
 					let data = if crate::tracing::if_tracing(|_| {}).is_none() &&
-						!self.exec_config.is_dry_run
+						self.exec_config.is_dry_run.is_none()
 					{
 						core::mem::replace(&mut output.data, Default::default())
 					} else {
@@ -1411,7 +1422,6 @@ where
 		} else {
 			self.transient_storage.rollback_transaction();
 		}
-
 		log::trace!(target: LOG_TARGET, "frame finished with: {output:?}");
 
 		self.pop_frame(success);