Transaction tracing for eth_call.

ethcore/src/client/client.rs

@@ -461,7 +461,7 @@ impl<V> BlockChainClient for Client<V> where V: Verifier {
 			// give the sender a sufficient balance
 			state.add_balance(&sender, &(needed_balance - balance));
 		}
-		let options = TransactOptions { tracing: false, vm_tracing: analytics.vm_tracing, check_nonce: false };
+		let options = TransactOptions { tracing: analytics.transaction_tracing, vm_tracing: analytics.vm_tracing, check_nonce: false };
 		let mut ret = Executive::new(&mut state, &env_info, self.engine.deref().deref(), &self.vm_factory).transact(t, options);
 		// TODO gav move this into Executive.
 		if analytics.state_diffing {

ethcore/src/client/mod.rs

@@ -52,6 +52,8 @@ use error::Error as EthError;
 /// Options concerning what analytics we run on the call.
 #[derive(Eq, PartialEq, Default, Clone, Copy, Debug)]
 pub struct CallAnalytics {
+	/// Make a transaction trace.
+	pub transaction_tracing: bool,
 	/// Make a VM trace.
 	pub vm_tracing: bool,
 	/// Make a diff.

ethcore/src/miner/miner.rs

@@ -276,7 +276,7 @@ impl MinerService for Miner {
 				// give the sender max balance
 				state.sub_balance(&sender, &balance);
 				state.add_balance(&sender, &U256::max_value());
-				let options = TransactOptions { tracing: false, vm_tracing: analytics.vm_tracing, check_nonce: false };
+				let options = TransactOptions { tracing: analytics.transaction_tracing, vm_tracing: analytics.vm_tracing, check_nonce: false };
 
 				let mut ret = Executive::new(&mut state, &env_info, self.engine(), chain.vm_factory()).transact(t, options);
 				// TODO gav move this into Executive.

rpc/src/v1/impls/traces.rs

@@ -28,7 +28,7 @@ use ethcore::state_diff::StateDiff;
 use ethcore::account_diff::{Diff, Existance};
 use ethcore::transaction::{Transaction as EthTransaction, SignedTransaction, Action};
 use v1::traits::Traces;
-use v1::types::{TraceFilter, Trace, BlockNumber, Index, CallRequest};
+use v1::types::{TraceFilter, LocalizedTrace, Trace, BlockNumber, Index, CallRequest};
 
 /// Traces api implementation.
 pub struct TracesClient<C, M> where C: BlockChainClient, M: MinerService {
@@ -156,7 +156,7 @@ impl<C, M> Traces for TracesClient<C, M> where C: BlockChainClient + 'static, M:
 			.and_then(|(filter, )| {
 				let client = take_weak!(self.client);
 				let traces = client.filter_traces(filter.into());
-				let traces = traces.map_or_else(Vec::new, |traces| traces.into_iter().map(Trace::from).collect());
+				let traces = traces.map_or_else(Vec::new, |traces| traces.into_iter().map(LocalizedTrace::from).collect());
 				to_value(&traces)
 			})
 	}
@@ -166,7 +166,7 @@ impl<C, M> Traces for TracesClient<C, M> where C: BlockChainClient + 'static, M:
 			.and_then(|(block_number,)| {
 				let client = take_weak!(self.client);
 				let traces = client.block_traces(block_number.into());
-				let traces = traces.map_or_else(Vec::new, |traces| traces.into_iter().map(Trace::from).collect());
+				let traces = traces.map_or_else(Vec::new, |traces| traces.into_iter().map(LocalizedTrace::from).collect());
 				to_value(&traces)
 			})
 	}
@@ -176,7 +176,7 @@ impl<C, M> Traces for TracesClient<C, M> where C: BlockChainClient + 'static, M:
 			.and_then(|(transaction_hash,)| {
 				let client = take_weak!(self.client);
 				let traces = client.transaction_traces(TransactionID::Hash(transaction_hash));
-				let traces = traces.map_or_else(Vec::new, |traces| traces.into_iter().map(Trace::from).collect());
+				let traces = traces.map_or_else(Vec::new, |traces| traces.into_iter().map(LocalizedTrace::from).collect());
 				to_value(&traces)
 			})
 	}
@@ -190,17 +190,32 @@ impl<C, M> Traces for TracesClient<C, M> where C: BlockChainClient + 'static, M:
 					address: address.into_iter().map(|i| i.value()).collect()
 				};
 				let trace = client.trace(id);
-				let trace = trace.map(Trace::from);
+				let trace = trace.map(LocalizedTrace::from);
 				to_value(&trace)
 			})
 	}
 
+	fn trace_call(&self, params: Params) -> Result<Value, Error> {
+		trace!(target: "jsonrpc", "trace_call: {:?}", params);
+		from_params(params)
+			.and_then(|(request,)| {
+				let signed = try!(self.sign_call(request));
+				let r = take_weak!(self.client).call(&signed, CallAnalytics{ transaction_tracing: true, vm_tracing: false, state_diffing: false });
+				if let Ok(executed) = r {
+					if let Some(trace) = executed.trace {
+						return to_value(&Trace::from(trace));
+					}
+				}
+				Ok(Value::Null)
+			})
+	}
+
 	fn vm_trace_call(&self, params: Params) -> Result<Value, Error> {
 		trace!(target: "jsonrpc", "vm_trace_call: {:?}", params);
 		from_params(params)
 			.and_then(|(request,)| {
 				let signed = try!(self.sign_call(request));
-				let r = take_weak!(self.client).call(&signed, CallAnalytics{ vm_tracing: true, state_diffing: false });
+				let r = take_weak!(self.client).call(&signed, CallAnalytics{ transaction_tracing: false, vm_tracing: true, state_diffing: false });
 				if let Ok(executed) = r {
 					if let Some(vm_trace) = executed.vm_trace {
 						return Ok(vm_trace_to_object(&vm_trace));
@@ -215,7 +230,7 @@ impl<C, M> Traces for TracesClient<C, M> where C: BlockChainClient + 'static, M:
 		from_params(params)
 			.and_then(|(request,)| {
 				let signed = try!(self.sign_call(request));
-				let r = take_weak!(self.client).call(&signed, CallAnalytics{ vm_tracing: false, state_diffing: true });
+				let r = take_weak!(self.client).call(&signed, CallAnalytics{ transaction_tracing: false, vm_tracing: false, state_diffing: true });
 				if let Ok(executed) = r {
 					if let Some(state_diff) = executed.state_diff {
 						return Ok(state_diff_to_object(&state_diff));

rpc/src/v1/traits/traces.rs

@@ -32,11 +32,14 @@ pub trait Traces: Sized + Send + Sync + 'static {
 	/// Returns all traces produced at given block.
 	fn block_traces(&self, _: Params) -> Result<Value, Error>;
 
+	/// Executes the given call and returns the transaction trace for it.
+	fn trace_call(&self, _: Params) -> Result<Value, Error>;
+
 	/// Executes the given call and returns the VM trace for it.
 	fn vm_trace_call(&self, _: Params) -> Result<Value, Error>;
 
 	/// Executes the given call and returns the diff for it.
-	fn state_diff_call(&self, params: Params) -> Result<Value, Error>;
+	fn state_diff_call(&self, _: Params) -> Result<Value, Error>;
 
 	/// Should be used to convert object to io delegate.
 	fn to_delegate(self) -> IoDelegate<Self> {
@@ -46,6 +49,7 @@ pub trait Traces: Sized + Send + Sync + 'static {
 		delegate.add_method("trace_transaction", Traces::transaction_traces);
 		delegate.add_method("trace_block", Traces::block_traces);
 
+		delegate.add_method("trace_traceCall", Traces::trace_call);
 		delegate.add_method("trace_vmTraceCall", Traces::vm_trace_call);
 		delegate.add_method("trace_stateDiffCall", Traces::state_diff_call);
 

rpc/src/v1/types/mod.rs.in

@@ -41,5 +41,5 @@ pub use self::transaction::Transaction;
 pub use self::transaction_request::{TransactionRequest, TransactionConfirmation, TransactionModification};
 pub use self::call_request::CallRequest;
 pub use self::receipt::Receipt;
-pub use self::trace::Trace;
+pub use self::trace::{Trace, LocalizedTrace};
 pub use self::trace_filter::TraceFilter;

rpc/src/v1/types/trace.rs

@@ -16,7 +16,7 @@
 
 use util::{Address, U256, H256};
 use ethcore::trace::trace;
-use ethcore::trace::LocalizedTrace;
+use ethcore::trace::{Trace as EthTrace, LocalizedTrace as EthLocalizedTrace};
 use v1::types::Bytes;
 
 /// Create response
@@ -161,7 +161,7 @@ impl From<trace::Res> for Res {
 
 /// Trace
 #[derive(Debug, Serialize)]
-pub struct Trace {
+pub struct LocalizedTrace {
 	/// Action
 	action: Action,
 	/// Result
@@ -185,9 +185,9 @@ pub struct Trace {
 	block_hash: H256,
 }
 
-impl From<LocalizedTrace> for Trace {
-	fn from(t: LocalizedTrace) -> Self {
-		Trace {
+impl From<EthLocalizedTrace> for LocalizedTrace {
+	fn from(t: EthLocalizedTrace) -> Self {
+		LocalizedTrace {
 			action: From::from(t.action),
 			result: From::from(t.result),
 			trace_address: t.trace_address.into_iter().map(From::from).collect(),
@@ -200,6 +200,30 @@ impl From<LocalizedTrace> for Trace {
 	}
 }
 
+/// Trace
+#[derive(Debug, Serialize)]
+pub struct Trace {
+	/// Depth within the call trace tree.
+	depth: usize,
+	/// Action
+	action: Action,
+	/// Result
+	result: Res,
+	/// Subtraces
+	subtraces: Vec<Trace>,
+}
+
+impl From<EthTrace> for Trace {
+	fn from(t: EthTrace) -> Self {
+		Trace {
+			depth: t.depth.into(),
+			action: t.action.into(),
+			result: t.result.into(),
+			subtraces: t.subs.into_iter().map(From::from).collect(),
+		}
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use serde_json;
@@ -209,7 +233,7 @@ mod tests {
 
 	#[test]
 	fn test_trace_serialize() {
-		let t = Trace {
+		let t = LocalizedTrace {
 			action: Action::Call(Call {
 				from: Address::from(4),
 				to: Address::from(5),