add withLog parameter to debug_traceCall

client/evm-tracing/src/formatters/blockscout.rs

@@ -89,4 +89,5 @@ pub struct BlockscoutCall {
 	pub gas_used: U256,
 	#[serde(flatten)]
 	pub inner: BlockscoutCallInner,
+	pub logs: Vec<crate::types::single::Log>,
 }

client/evm-tracing/src/formatters/call_tracer.rs

@@ -16,7 +16,7 @@
 
 use super::blockscout::BlockscoutCallInner;
 use crate::types::{
-	single::{Call, TransactionTrace},
+	single::{Call, Log, TransactionTrace},
 	CallResult, CallType, CreateResult,
 };
 
@@ -70,8 +70,12 @@ impl super::ResponseFormatter for Formatter {
 								},
 								to,
 								input,
-								res,
+								res: res.clone(),
 								value: Some(value),
+								logs: match res {
+									CallResult::Output { .. } => it.logs.clone(),
+									CallResult::Error { .. } => Vec::new(),
+								},
 							},
 							BlockscoutCallInner::Create { init, res } => CallTracerInner::Create {
 								input: init,
@@ -285,6 +289,9 @@ pub enum CallTracerInner {
 
 		#[serde(skip_serializing_if = "Option::is_none")]
 		value: Option<U256>,
+
+		#[serde(skip_serializing_if = "Vec::is_empty")]
+		logs: Vec<Log>,
 	},
 	Create {
 		#[serde(rename = "type", serialize_with = "opcode_serialize")]

client/evm-tracing/src/listeners/call_list.rs

@@ -16,7 +16,7 @@
 
 use crate::formatters::blockscout::BlockscoutCall as Call;
 use crate::formatters::blockscout::BlockscoutCallInner as CallInner;
-use crate::types::{CallResult, CallType, ContextType, CreateResult};
+use crate::types::{single::Log, CallResult, CallType, ContextType, CreateResult};
 use ethereum_types::{H160, U256};
 use evm_tracing_events::{
 	runtime::{Capture, ExitError, ExitReason, ExitSucceed},
@@ -50,7 +50,7 @@ pub struct Listener {
 	// Next index to use.
 	entries_next_index: u32,
 	// Stack of contexts with data to keep between events.
-	context_stack: Vec<Context>,
+	pub(crate) context_stack: Vec<Context>,
 
 	// Type of the next call.
 	// By default is None and corresponds to the root call, which
@@ -79,9 +79,12 @@ pub struct Listener {
 	/// True if only the `GasometerEvent::RecordTransaction` event has been received.
 	/// Allow to correctly handle transactions that cannot pay for the tx data in Legacy mode.
 	record_transaction_event_only: bool,
+
+	/// If true the listener will collect EvmEvent::Log events.
+	pub with_log: bool,
 }
 
-struct Context {
+pub struct Context {
 	entries_index: u32,
 
 	context_type: ContextType,
@@ -98,6 +101,8 @@ struct Context {
 	data: Vec<u8>,
 	// to / create address
 	to: H160,
+
+	logs: Vec<Log>,
 }
 
 impl Default for Listener {
@@ -116,6 +121,7 @@ impl Default for Listener {
 			skip_next_context: false,
 			call_list_first_transaction: true,
 			record_transaction_event_only: false,
+			with_log: false,
 		}
 	}
 }
@@ -160,6 +166,7 @@ impl Listener {
 							input: context.data,
 							res,
 						},
+						logs: context.logs,
 					}
 				}
 				ContextType::Create => {
@@ -178,6 +185,7 @@ impl Listener {
 							init: context.data,
 							res,
 						},
+						logs: context.logs,
 					}
 				}
 			};
@@ -208,6 +216,7 @@ impl Listener {
 					input: vec![],
 					res,
 				},
+				logs: Vec::<Log>::new(),
 			};
 
 			self.insert_entry(self.entries_next_index, entry);
@@ -300,6 +309,8 @@ impl Listener {
 
 					data,
 					to: address,
+
+					logs: Vec::new(),
 				});
 
 				self.entries_next_index += 1;
@@ -330,6 +341,8 @@ impl Listener {
 
 					data: init_code,
 					to: address,
+
+					logs: Vec::new(),
 				});
 
 				self.entries_next_index += 1;
@@ -360,6 +373,8 @@ impl Listener {
 
 					data: init_code,
 					to: address,
+
+					logs: Vec::new(),
 				});
 
 				self.entries_next_index += 1;
@@ -415,6 +430,8 @@ impl Listener {
 
 						data: input.to_vec(),
 						to: code_address,
+
+						logs: Vec::new(),
 					});
 
 					self.entries_next_index += 1;
@@ -458,6 +475,8 @@ impl Listener {
 
 						data: init_code.to_vec(),
 						to: address,
+
+						logs: Vec::new(),
 					});
 
 					self.entries_next_index += 1;
@@ -492,6 +511,7 @@ impl Listener {
 							to: target,
 							balance,
 						},
+						logs: Vec::<Log>::new(),
 					},
 				);
 				self.entries_next_index += 1;
@@ -519,6 +539,21 @@ impl Listener {
 				// behavior (like batch precompile does) thus we simply consider this a call.
 				self.call_type = Some(CallType::Call);
 			}
+			EvmEvent::Log {
+				address,
+				topics,
+				data,
+			} => {
+				if self.with_log {
+					if let Some(stack) = self.context_stack.last_mut() {
+						stack.logs.push(Log {
+							address,
+							topics,
+							data,
+						});
+					}
+				}
+			}
 
 			// We ignore other kinds of message if any (new ones may be added in the future).
 			#[allow(unreachable_patterns)]
@@ -577,6 +612,7 @@ impl Listener {
 								input: context.data,
 								res,
 							},
+							logs: context.logs,
 						}
 					}
 					ContextType::Create => {
@@ -605,6 +641,7 @@ impl Listener {
 								init: context.data,
 								res,
 							},
+							logs: context.logs,
 						}
 					}
 				},
@@ -665,6 +702,7 @@ impl ListenerT for Listener {
 #[allow(unused)]
 mod tests {
 	use super::*;
+	use crate::formatters::blockscout::BlockscoutCallInner;
 	use ethereum_types::H256;
 	use evm_tracing_events::{
 		evm::CreateScheme,
@@ -681,6 +719,7 @@ mod tests {
 		TransactCall,
 		TransactCreate,
 		TransactCreate2,
+		Log,
 	}
 
 	enum TestRuntimeEvent {
@@ -782,6 +821,11 @@ mod tests {
 				gas_limit: 0u64,
 				address: H160::default(),
 			},
+			TestEvmEvent::Log => EvmEvent::Log {
+				address: H160::default(),
+				topics: Vec::new(),
+				data: Vec::new(),
+			},
 		}
 	}
 
@@ -876,6 +920,10 @@ mod tests {
 		listener.evm_event(test_emit_evm_event(TestEvmEvent::Suicide, false, None));
 	}
 
+	fn do_evm_log_event(listener: &mut Listener) {
+		listener.evm_event(test_emit_evm_event(TestEvmEvent::Log, false, None));
+	}
+
 	fn do_runtime_step_event(listener: &mut Listener) {
 		listener.runtime_event(test_emit_runtime_event(TestRuntimeEvent::Step));
 	}
@@ -1127,4 +1175,47 @@ mod tests {
 		// There are 5 main nested calls for a total of 56 elements in the callstack: 1 main + 55 nested.
 		assert_eq!(listener.entries[0].len(), (depth * (subdepth + 1)) + 1);
 	}
+
+	#[test]
+	fn call_log_event() {
+		let mut listener = Listener::default();
+		listener.with_log = true;
+		do_transact_create_event(&mut listener);
+		do_gasometer_event(&mut listener);
+		do_evm_create_event(&mut listener);
+		do_evm_call_event(&mut listener);
+		do_evm_log_event(&mut listener);
+		do_exit_event(&mut listener);
+		listener.finish_transaction();
+		assert_eq!(listener.entries.len(), 1);
+		assert_eq!(listener.entries[0].len(), 2);
+		assert_eq!(listener.entries[0].get(&1).unwrap().logs.len(), 1);
+	}
+
+	#[test]
+	fn call_multiple_logs_event() {
+		let mut listener = Listener::default();
+		listener.with_log = true;
+		do_evm_call_event(&mut listener);
+		do_evm_log_event(&mut listener);
+		do_evm_log_event(&mut listener);
+		do_exit_event(&mut listener);
+		listener.finish_transaction();
+		assert_eq!(listener.entries.len(), 1);
+		assert_eq!(listener.entries[0].len(), 1);
+		assert_eq!(listener.entries[0].get(&0).unwrap().logs.len(), 2);
+	}
+
+	#[test]
+	fn call_log_event_not_recorder_when_with_log_is_false() {
+		let mut listener = Listener::default();
+		do_evm_call_event(&mut listener);
+		do_evm_log_event(&mut listener);
+		do_evm_log_event(&mut listener);
+		do_exit_event(&mut listener);
+		listener.finish_transaction();
+		assert_eq!(listener.entries.len(), 1);
+		assert_eq!(listener.entries[0].len(), 1);
+		assert_eq!(listener.entries[0].get(&0).unwrap().logs.len(), 0);
+	}
 }

client/evm-tracing/src/types/single.rs

@@ -20,9 +20,9 @@
 //! the whole block tracing output.
 
 use super::serialization::*;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
-use ethereum_types::{H256, U256};
+use ethereum_types::{H160, H256, U256};
 use parity_scale_codec::{Decode, Encode};
 use sp_std::{collections::btree_map::BTreeMap, vec::Vec};
 
@@ -100,3 +100,25 @@ pub struct RawStepLog {
 	#[serde(skip_serializing_if = "Option::is_none")]
 	pub storage: Option<BTreeMap<H256, H256>>,
 }
+
+#[derive(Clone, Eq, PartialEq, Debug, Encode, Decode, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TraceCallConfig {
+	pub with_log: bool,
+}
+
+impl Default for TraceCallConfig {
+	fn default() -> Self {
+		Self { with_log: false }
+	}
+}
+
+#[derive(Clone, Debug, Encode, Decode, PartialEq, Eq, Serialize)]
+pub struct Log {
+	/// Event address.
+	pub address: H160,
+	/// Event topics
+	pub topics: Vec<H256>,
+	/// Event data
+	pub data: Vec<u8>,
+}

client/rpc-core/debug/src/lib.rs

@@ -30,6 +30,7 @@ pub struct TraceParams {
 	pub disable_stack: Option<bool>,
 	/// Javascript tracer (we just check if it's Blockscout tracer string)
 	pub tracer: Option<String>,
+	pub tracer_config: Option<single::TraceCallConfig>,
 	pub timeout: Option<String>,
 }