diff --git a/ethcore/src/executive.rs b/ethcore/src/executive.rs
index 7ae43ff0a..e4d0650d0 100644
--- a/ethcore/src/executive.rs
+++ b/ethcore/src/executive.rs
@@ -260,16 +260,14 @@ impl<'a> Executive<'a> {
 
 			// if there's tracing, make up trace_info's result with trace_output and some arithmetic. 
 			if let Some((TraceAction::Call(ref mut c), _)) = trace_info {
-				if let Some(output) = trace_output { 
-					c.result = res.as_ref().ok().map(|gas_left| (c.gas - *gas_left, output));
-				}
+				c.result = res.as_ref().ok().map(|gas_left| (c.gas - *gas_left, trace_output.expect("trace_info is Some: qed")));
 			}
 
-			trace!("exec: sstore-clears={}\n", unconfirmed_substate.sstore_clears_count);
-			trace!("exec: substate={:?}; unconfirmed_substate={:?}\n", substate, unconfirmed_substate);
+			trace!(target: "executive", "sstore-clears={}\n", unconfirmed_substate.sstore_clears_count);
+			trace!(target: "executive", "substate={:?}; unconfirmed_substate={:?}\n", substate, unconfirmed_substate);
 
 			self.enact_result(&res, substate, unconfirmed_substate, trace_info);
-			trace!("exec: new substate={:?}\n", substate);
+			trace!(target: "executive", "enacted: substate={:?}\n", substate);
 			res
 		} else {
 			// otherwise, nothing
diff --git a/ethcore/src/externalities.rs b/ethcore/src/externalities.rs
index a6f7e4f36..3f9d4ff08 100644
--- a/ethcore/src/externalities.rs
+++ b/ethcore/src/externalities.rs
@@ -153,13 +153,15 @@ impl<'a> Ext for Externalities<'a> {
 	}
 
 	fn call(&mut self,
-			gas: &U256,
-			sender_address: &Address,
-			receive_address: &Address,
-			value: Option<U256>,
-			data: &[u8],
-			code_address: &Address,
-			output: &mut [u8]) -> MessageCallResult {
+		gas: &U256,
+		sender_address: &Address,
+		receive_address: &Address,
+		value: Option<U256>,
+		data: &[u8],
+		code_address: &Address,
+		output: &mut [u8]
+	) -> MessageCallResult {
+		trace!(target: "externalities", "call");
 
 		let mut params = ActionParams {
 			sender: sender_address.clone(),
diff --git a/ethcore/src/state.rs b/ethcore/src/state.rs
index 6135528c0..b5b312076 100644
--- a/ethcore/src/state.rs
+++ b/ethcore/src/state.rs
@@ -429,6 +429,313 @@ fn should_trace_failed_create_transaction() {
 	assert_eq!(result.trace, expected_trace);
 }
 
+#[test]
+fn should_trace_call_transaction() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = TestEngine::new(5, Factory::default());
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Call(x!(0xa)),
+		value: x!(100),
+		data: vec![],
+	}.sign(&"".sha3());
+
+	state.init_code(&x!(0xa), FromHex::from_hex("6000").unwrap());
+	state.add_balance(t.sender().as_ref().unwrap(), &x!(100));
+	let result = state.apply(&info, &engine, &t, true).unwrap();
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: TraceAction::Call(TraceCall {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			to: x!(0xa),
+			value: x!(100),
+			gas: x!(79000),
+			input: vec![],
+			result: Some((x!(3), vec![]))
+		}),
+		subs: vec![]
+	});
+
+	assert_eq!(result.trace, expected_trace);
+}
+
+
+#[test]
+fn should_trace_failed_call_transaction() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = TestEngine::new(5, Factory::default());
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Call(x!(0xa)),
+		value: x!(100),
+		data: vec![],
+	}.sign(&"".sha3());
+
+	state.init_code(&x!(0xa), FromHex::from_hex("5b600056").unwrap());
+	state.add_balance(t.sender().as_ref().unwrap(), &x!(100));
+	let result = state.apply(&info, &engine, &t, true).unwrap();
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: TraceAction::Call(TraceCall {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			to: x!(0xa),
+			value: x!(100),
+			gas: x!(79000),
+			input: vec![],
+			result: None
+		}),
+		subs: vec![]
+	});
+
+	println!("trace: {:?}", result.trace);
+
+	assert_eq!(result.trace, expected_trace);
+}
+#[test]
+fn should_trace_call_with_subcall_transaction() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = TestEngine::new(5, Factory::default());
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Call(x!(0xa)),
+		value: x!(100),
+		data: vec![],
+	}.sign(&"".sha3());
+
+	state.init_code(&x!(0xa), FromHex::from_hex("60006000600060006000600b602b5a03f1").unwrap());
+	state.init_code(&x!(0xb), FromHex::from_hex("6000").unwrap());
+	state.add_balance(t.sender().as_ref().unwrap(), &x!(100));
+	let result = state.apply(&info, &engine, &t, true).unwrap();
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: TraceAction::Call(TraceCall {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			to: x!(0xa),
+			value: x!(100),
+			gas: x!(79000),
+			input: vec![],
+			result: Some((x!(69), vec![]))
+		}),
+		subs: vec![Trace {
+			depth: 1,
+			action: TraceAction::Call(TraceCall {
+				from: x!(0xa),
+				to: x!(0xb),
+				value: x!(0),
+				gas: x!(78934),
+				input: vec![],
+				result: Some((x!(3), vec![]))
+			}),
+			subs: vec![]
+		}]
+	});
+
+	assert_eq!(result.trace, expected_trace);
+}
+
+#[test]
+fn should_trace_failed_subcall_transaction() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = TestEngine::new(5, Factory::default());
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Call(x!(0xa)),
+		value: x!(100),
+		data: vec![],//600480600b6000396000f35b600056
+	}.sign(&"".sha3());
+
+	state.init_code(&x!(0xa), FromHex::from_hex("60006000600060006000600b602b5a03f1").unwrap());
+	state.init_code(&x!(0xb), FromHex::from_hex("5b600056").unwrap());
+	state.add_balance(t.sender().as_ref().unwrap(), &x!(100));
+	let result = state.apply(&info, &engine, &t, true).unwrap();
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: TraceAction::Call(TraceCall {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			to: x!(0xa),
+			value: x!(100),
+			gas: x!(79000),
+			input: vec![],
+			result: Some((x!(79000), vec![]))
+		}),
+		subs: vec![Trace {
+			depth: 1,
+			action: TraceAction::Call(TraceCall {
+				from: x!(0xa),
+				to: x!(0xb),
+				value: x!(0),
+				gas: x!(78934),
+				input: vec![],
+				result: None
+			}),
+			subs: vec![]
+		}]
+	});
+
+	assert_eq!(result.trace, expected_trace);
+}
+
+#[test]
+fn should_trace_call_with_subcall_with_subcall_transaction() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = TestEngine::new(5, Factory::default());
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Call(x!(0xa)),
+		value: x!(100),
+		data: vec![],
+	}.sign(&"".sha3());
+
+	state.init_code(&x!(0xa), FromHex::from_hex("60006000600060006000600b602b5a03f1").unwrap());
+	state.init_code(&x!(0xb), FromHex::from_hex("60006000600060006000600c602b5a03f1").unwrap());
+	state.init_code(&x!(0xc), FromHex::from_hex("6000").unwrap());
+	state.add_balance(t.sender().as_ref().unwrap(), &x!(100));
+	let result = state.apply(&info, &engine, &t, true).unwrap();
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: TraceAction::Call(TraceCall {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			to: x!(0xa),
+			value: x!(100),
+			gas: x!(79000),
+			input: vec![],
+			result: Some((x!(135), vec![]))
+		}),
+		subs: vec![Trace {
+			depth: 1,
+			action: TraceAction::Call(TraceCall {
+				from: x!(0xa),
+				to: x!(0xb),
+				value: x!(0),
+				gas: x!(78934),
+				input: vec![],
+				result: Some((x!(69), vec![]))
+			}),
+			subs: vec![Trace {
+				depth: 2,
+				action: TraceAction::Call(TraceCall {
+					from: x!(0xb),
+					to: x!(0xc),
+					value: x!(0),
+					gas: x!(78868),
+					input: vec![],
+					result: Some((x!(3), vec![]))
+				}),
+				subs: vec![]
+			}]
+		}]
+	});
+
+	assert_eq!(result.trace, expected_trace);
+}
+
+#[test]
+fn should_trace_failed_subcall_with_subcall_transaction() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = TestEngine::new(5, Factory::default());
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Call(x!(0xa)),
+		value: x!(100),
+		data: vec![],//600480600b6000396000f35b600056
+	}.sign(&"".sha3());
+
+	state.init_code(&x!(0xa), FromHex::from_hex("60006000600060006000600b602b5a03f1").unwrap());
+	state.init_code(&x!(0xb), FromHex::from_hex("60006000600060006000600c602b5a03f1505b601256").unwrap());
+	state.init_code(&x!(0xc), FromHex::from_hex("6000").unwrap());
+	state.add_balance(t.sender().as_ref().unwrap(), &x!(100));
+	let result = state.apply(&info, &engine, &t, true).unwrap();
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: TraceAction::Call(TraceCall {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			to: x!(0xa),
+			value: x!(100),
+			gas: x!(79000),
+			input: vec![],
+			result: Some((x!(79000), vec![]))
+		}),
+		subs: vec![Trace {
+			depth: 1,
+			action: TraceAction::Call(TraceCall {
+				from: x!(0xa),
+				to: x!(0xb),
+				value: x!(0),
+				gas: x!(78934),
+				input: vec![],
+				result: None
+			}),
+			subs: vec![Trace {
+				depth: 2,
+				action: TraceAction::Call(TraceCall {
+					from: x!(0xb),
+					to: x!(0xc),
+					value: x!(0),
+					gas: x!(78868),
+					input: vec![],
+					result: Some((x!(3), vec![])),
+				}),
+				subs: vec![]
+			}]
+		}]
+	});
+
+	assert_eq!(result.trace, expected_trace);
+}
 
 #[test]
 fn code_from_database() {