[pallet-revive] add tracing support (3/3)

substrate/bin/node/runtime/src/lib.rs

@@ -3303,18 +3303,49 @@ impl_runtime_apis! {
 		}
 
 		fn trace_block(
-			_block: Block,
-			_config: pallet_revive::evm::TracerConfig
+			block: Block,
+			config: pallet_revive::evm::TracerConfig
 		) -> Result<Vec<(u32, pallet_revive::evm::EthTraces)>, sp_runtime::DispatchError> {
-			unimplemented!()
+			let mut tracer = pallet_revive::debug::Tracer::from_config(config);
+			let mut traces = vec![];
+
+			pallet_revive::using_tracer(&mut tracer, || {
+				Executive::initialize_block(block.header());
+
+				for (index, ext) in block.extrinsics().into_iter().enumerate() {
+					let _ = Executive::apply_extrinsic(ext.clone());
+					pallet_revive::with_tracer(|tracer| {
+						if !tracer.has_traces() {
+							let tx_traces = tracer.collect_traces().as_eth_traces::<Runtime>();
+							 traces.push((index as u32, tx_traces));
+						}
+					});
+				}
+			});
+
+			Ok(traces)
 		}
 
 		fn trace_tx(
-			_block: Block,
-			_tx_index: u32,
-			_config: pallet_revive::evm::TracerConfig
+			block: Block,
+			tx_index: u32,
+			config: pallet_revive::evm::TracerConfig
 		) -> Result<pallet_revive::evm::EthTraces, sp_runtime::DispatchError> {
-			unimplemented!()
+			let mut tracer = pallet_revive::debug::Tracer::from_config(config);
+			Executive::initialize_block(block.header());
+
+			for (index, ext) in block.extrinsics().into_iter().enumerate() {
+				if index as u32 == tx_index {
+					pallet_revive::using_tracer(&mut tracer, || {
+						let _ = Executive::apply_extrinsic(ext.clone());
+					});
+					break;
+				} else {
+					let _ = Executive::apply_extrinsic(ext.clone());
+				}
+			}
+
+			Ok(tracer.collect_traces().as_eth_traces::<Runtime>())
 		}
 	}
 

substrate/client/rpc-api/src/state/mod.rs

@@ -38,6 +38,49 @@ pub trait StateApi<Hash> {
 	#[method(name = "state_call", aliases = ["state_callAt"], blocking)]
 	fn call(&self, name: String, bytes: Bytes, hash: Option<Hash>) -> Result<Bytes, Error>;
 
+	/// Retrieve the block using the specified hash and invoke a runtime API method from the parent
+	/// state of this block. This allows the method to replay the extrinsics from the parent state
+	/// of the block.
+	///
+	/// This is typically used to replay transactions with tracing enabled. For example,
+	/// `pallet_revive` uses this to capture smart-contract call traces.
+	///
+	/// # Parameters
+	/// - `name`: The name of the runtime API method to call.
+	/// - `block`: The hash of the block to replay.
+	/// - `bytes`: Additional, encoded data to pass to the runtime API method, after the block data.
+	///
+	/// # `curl` example
+	///
+	/// - Call `pallet_revive` [`trace_block`](https://paritytech.github.io/polkadot-sdk/master/pallet_revive/trait.ReviveApi.html#method.trace_block)
+	///   to replay a block and capture call traces.
+	///
+	/// ```text
+	/// curl  http://localhost:9944 \
+	/// 	-H 'Content-Type: application/json' \
+	/// 	-d '{
+	/// 	      "id":1, "jsonrpc":"2.0", "method":"state_debugBlock", \
+	/// 	      "params": ["ReviveApi_trace_block", "0xb246acf1adea1f801ce15c77a5fa7d8f2eb8fed466978bcee172cc02cf64e264"]
+	///         }'
+	/// }'
+	/// ```
+	///
+	/// - Call `pallet_revive` [`trace_tx`](https://paritytech.github.io/polkadot-sdk/master/pallet_revive/trait.ReviveApi.html#method.trace_block)
+	///   to replay a block and capture the call trace of the transaction at the given index.
+	///
+	/// ```text
+	/// curl  http://localhost:9944 \
+	/// 	-H 'Content-Type: application/json' \
+	/// 	-d '{
+	/// 	      "id":1, "jsonrpc":"2.0", "method":"state_debugBlock", \
+	/// 	      "params": ["ReviveApi_trace_tx",
+	/// "0xb246acf1adea1f801ce15c77a5fa7d8f2eb8fed466978bcee172cc02cf64e264", "0x2a000000"]
+	///         }'
+	/// }'
+	/// ```
+	#[method(name = "state_debugBlock", blocking, with_extensions)]
+	fn debug_block(&self, name: String, block: Hash, bytes: Bytes) -> Result<Bytes, Error>;
+
 	/// Returns the keys with prefix, leave empty to get all the keys.
 	#[method(name = "state_getKeys", blocking)]
 	#[deprecated(since = "2.0.0", note = "Please use `getKeysPaged` with proper paging support")]

substrate/client/rpc/src/state/mod.rs

@@ -59,6 +59,15 @@ where
 		call_data: Bytes,
 	) -> Result<Bytes, Error>;
 
+	/// Call the runtime method at the block's parent state.
+	/// and pass the block to be replayed, followed by the call data.
+	fn debug_block(
+		&self,
+		method: String,
+		block: Block::Hash,
+		extra_call_data: Bytes,
+	) -> Result<Bytes, Error>;
+
 	/// Returns the keys with prefix, leave empty to get all the keys.
 	fn storage_keys(
 		&self,
@@ -209,6 +218,17 @@ where
 		self.backend.call(block, method, data).map_err(Into::into)
 	}
 
+	fn debug_block(
+		&self,
+		ext: &Extensions,
+		method: String,
+		block: Block::Hash,
+		data: Bytes,
+	) -> Result<Bytes, Error> {
+		check_if_safe(ext)?;
+		self.backend.debug_block(method, block, data).map_err(Into::into)
+	}
+
 	fn storage_keys(
 		&self,
 		key_prefix: StorageKey,

substrate/client/rpc/src/state/state_full.rs

@@ -204,6 +204,39 @@ where
 			.map_err(client_err)
 	}
 
+	fn debug_block(
+		&self,
+		method: String,
+		block: Block::Hash,
+		extra_call_data: Bytes,
+	) -> std::result::Result<Bytes, Error> {
+		use sp_runtime::traits::Header;
+		let header = self
+			.client
+			.header(block)
+			.map_err(|err| Error::Client(Box::new(err)))?
+			.ok_or_else(|| Error::Client("Block hash not found".into()))?;
+
+		let parent_hash = header.parent_hash().clone();
+		let extrinsics = self
+			.client
+			.block_body(block)
+			.map_err(|err| Error::Client(Box::new(err)))?
+			.ok_or_else(|| Error::Client("Block hash not found".into()))?;
+
+		let call_data = Block::new(header, extrinsics)
+			.encode()
+			.into_iter()
+			.chain(extra_call_data.0.into_iter())
+			.collect::<Vec<u8>>();
+
+		self.client
+			.executor()
+			.call(parent_hash, &method, &call_data, CallContext::Offchain)
+			.map(Into::into)
+			.map_err(client_err)
+	}
+
 	// TODO: This is horribly broken; either remove it, or make it streaming.
 	fn storage_keys(
 		&self,