Avoided Changing non-RPC Types

ethcore/src/client/client.rs

@@ -1541,15 +1541,15 @@ impl EngineInfo for Client {
 }
 
 impl BlockChainClient for Client {
-	fn replay(&self, id: TransactionId, analytics: CallAnalytics) -> Result<Executed, CallError> {
+	fn replay(&self, id: TransactionId, analytics: CallAnalytics) -> Result<(Option<H256>, Executed), CallError> {
 		let address = self.transaction_address(id).ok_or(CallError::TransactionNotFound)?;
 		let block = BlockId::Hash(address.block_hash);
 
 		const PROOF: &'static str = "The transaction address contains a valid index within block; qed";
 		Ok(self.replay_block_transactions(block, analytics)?.nth(address.index).expect(PROOF))
 	}
 
-	fn replay_block_transactions(&self, block: BlockId, analytics: CallAnalytics) -> Result<Box<Iterator<Item = Executed>>, CallError> {
+	fn replay_block_transactions(&self, block: BlockId, analytics: CallAnalytics) -> Result<Box<Iterator<Item = (Option<H256>,Executed)>>, CallError> {
 		let mut env_info = self.env_info(block).ok_or(CallError::StatePruned)?;
 		let body = self.block_body(block).ok_or(CallError::StatePruned)?;
 		let mut state = self.state_at_beginning(block).ok_or(CallError::StatePruned)?;
@@ -1561,11 +1561,12 @@ impl BlockChainClient for Client {
 
 		Ok(Box::new(txs.into_iter()
 			.map(move |t| {
+				let tx_hash = t.hash();
 				let t = SignedTransaction::new(t).expect(PROOF);
 				let machine = engine.machine();
 				let x = Self::do_virtual_call(machine, &env_info, &mut state, &t, analytics).expect(EXECUTE_PROOF);
 				env_info.gas_used = env_info.gas_used + x.gas_used;
-				x
+				(Some(tx_hash),x)
 			})))
 	}
 

ethcore/src/client/test_client.rs

@@ -607,12 +607,12 @@ impl EngineInfo for TestBlockChainClient {
 }
 
 impl BlockChainClient for TestBlockChainClient {
-	fn replay(&self, _id: TransactionId, _analytics: CallAnalytics) -> Result<Executed, CallError> {
-		self.execution_result.read().clone().unwrap()
+	fn replay(&self, _id: TransactionId, _analytics: CallAnalytics) -> Result<(Option<H256>,Executed), CallError> {
+		Ok((None,self.execution_result.read().clone().unwrap()?))
 	}
 
-	fn replay_block_transactions(&self, _block: BlockId, _analytics: CallAnalytics) -> Result<Box<Iterator<Item = Executed>>, CallError> {
-		Ok(Box::new(self.execution_result.read().clone().unwrap().into_iter()))
+	fn replay_block_transactions(&self, _block: BlockId, _analytics: CallAnalytics) -> Result<Box<Iterator<Item = (Option<H256>,Executed)>>, CallError> {
+		Ok(Box::new(None.into_iter().zip(self.execution_result.read().clone().unwrap().into_iter())))
 	}
 
 	fn block_total_difficulty(&self, _id: BlockId) -> Option<U256> {

ethcore/src/client/traits.rs

@@ -300,10 +300,10 @@ pub trait BlockChainClient : Sync + Send + AccountData + BlockChain + CallContra
 	fn logs(&self, filter: Filter) -> Vec<LocalizedLogEntry>;
 
 	/// Replays a given transaction for inspection.
-	fn replay(&self, t: TransactionId, analytics: CallAnalytics) -> Result<Executed, CallError>;
+	fn replay(&self, t: TransactionId, analytics: CallAnalytics) -> Result<(Option<H256>,Executed), CallError>;
 
 	/// Replays all the transactions in a given block for inspection.
-	fn replay_block_transactions(&self, block: BlockId, analytics: CallAnalytics) -> Result<Box<Iterator<Item = Executed>>, CallError>;
+	fn replay_block_transactions(&self, block: BlockId, analytics: CallAnalytics) -> Result<Box<Iterator<Item = (Option<H256>,Executed)>>, CallError>;
 
 	/// Returns traces matching given filter.
 	fn filter_traces(&self, filter: TraceFilter) -> Option<Vec<LocalizedTrace>>;

rpc/src/v1/impls/light/trace.rs

@@ -21,7 +21,7 @@ use jsonrpc_macros::Trailing;
 use v1::Metadata;
 use v1::traits::Traces;
 use v1::helpers::errors;
-use v1::types::{TraceFilter, LocalizedTrace, BlockNumber, Index, CallRequest, Bytes, TraceResults, TraceOptions, H256};
+use v1::types::{TraceFilter, LocalizedTrace, BlockNumber, Index, CallRequest, Bytes, TraceResults, TraceResultsWithTransHash, TraceOptions, H256};
 
 /// Traces api implementation.
 // TODO: all calling APIs should be possible w. proved remote TX execution.
@@ -58,11 +58,11 @@ impl Traces for TracesClient {
 		Err(errors::light_unimplemented(None))
 	}
 
-	fn replay_transaction(&self, _transaction_hash: H256, _flags: TraceOptions) -> Result<TraceResults> {
+	fn replay_transaction(&self, _transaction_hash: H256, _flags: TraceOptions) -> Result<TraceResultsWithTransHash> {
 		Err(errors::light_unimplemented(None))
 	}
 
-	fn replay_block_transactions(&self,  _block_number: BlockNumber, _flags: TraceOptions) ->  Result<Vec<TraceResults>> {
+	fn replay_block_transactions(&self,  _block_number: BlockNumber, _flags: TraceOptions) ->  Result<Vec<TraceResultsWithTransHash>> {
 		Err(errors::light_unimplemented(None))
 	}
 }

rpc/src/v1/impls/traces.rs

@@ -27,7 +27,7 @@ use jsonrpc_macros::Trailing;
 use v1::Metadata;
 use v1::traits::Traces;
 use v1::helpers::{errors, fake_sign};
-use v1::types::{TraceFilter, LocalizedTrace, BlockNumber, Index, CallRequest, Bytes, TraceResults, TraceOptions, H256, block_number_to_id};
+use v1::types::{TraceFilter, LocalizedTrace, BlockNumber, Index, CallRequest, Bytes, TraceResults, TraceResultsWithTransHash, TraceOptions, H256, block_number_to_id};
 
 fn to_call_analytics(flags: TraceOptions) -> CallAnalytics {
 	CallAnalytics {
@@ -158,13 +158,13 @@ impl<C, S> Traces for TracesClient<C> where
 			.map_err(errors::call)
 	}
 
-	fn replay_transaction(&self, transaction_hash: H256, flags: TraceOptions) -> Result<TraceResults> {
+	fn replay_transaction(&self, transaction_hash: H256, flags: TraceOptions) -> Result<TraceResultsWithTransHash> {
 		self.client.replay(TransactionId::Hash(transaction_hash.into()), to_call_analytics(flags))
-			.map(TraceResults::from)
+			.map(TraceResultsWithTransHash::from)
 			.map_err(errors::call)
 	}
 
-	fn replay_block_transactions(&self, block_number: BlockNumber, flags: TraceOptions) -> Result<Vec<TraceResults>> {
+	fn replay_block_transactions(&self, block_number: BlockNumber, flags: TraceOptions) -> Result<Vec<TraceResultsWithTransHash>> {
 		let id = match block_number {
 			BlockNumber::Num(num) => BlockId::Number(num),
 			BlockNumber::Earliest => BlockId::Earliest,
@@ -174,7 +174,7 @@ impl<C, S> Traces for TracesClient<C> where
 		};
 
 		self.client.replay_block_transactions(id, to_call_analytics(flags))
-			.map(|results| results.into_iter().map(TraceResults::from).collect())
+			.map(|results| results.into_iter().map(TraceResultsWithTransHash::from).collect())
 			.map_err(errors::call)
 	}
 }

rpc/src/v1/traits/traces.rs

@@ -18,7 +18,7 @@
 
 use jsonrpc_core::Result;
 use jsonrpc_macros::Trailing;
-use v1::types::{TraceFilter, LocalizedTrace, BlockNumber, Index, CallRequest, Bytes, TraceResults, H256, TraceOptions};
+use v1::types::{TraceFilter, LocalizedTrace, BlockNumber, Index, CallRequest, Bytes, TraceResults, TraceResultsWithTransHash, H256, TraceOptions};
 
 build_rpc_trait! {
 	/// Traces specific rpc interface.
@@ -55,10 +55,10 @@ build_rpc_trait! {
 
 		/// Executes the transaction with the given hash and returns a number of possible traces for it.
 		#[rpc(name = "trace_replayTransaction")]
-		fn replay_transaction(&self, H256, TraceOptions) -> Result<TraceResults>;
+		fn replay_transaction(&self, H256, TraceOptions) -> Result<TraceResultsWithTransHash>;
 
 		/// Executes all the transactions at the given block and returns a number of possible traces for each transaction.
 		#[rpc(name = "trace_replayBlockTransactions")]
-		fn replay_block_transactions(&self, BlockNumber, TraceOptions) ->  Result<Vec<TraceResults>>;
+		fn replay_block_transactions(&self, BlockNumber, TraceOptions) ->  Result<Vec<TraceResultsWithTransHash>>;
 	}
 }

rpc/src/v1/types/mod.rs

@@ -73,7 +73,7 @@ pub use self::sync::{
 	SyncStatus, SyncInfo, Peers, PeerInfo, PeerNetworkInfo, PeerProtocolsInfo,
 	TransactionStats, ChainStatus, EthProtocolInfo, PipProtocolInfo,
 };
-pub use self::trace::{LocalizedTrace, TraceResults};
+pub use self::trace::{LocalizedTrace, TraceResults, TraceResultsWithTransHash};
 pub use self::trace_filter::TraceFilter;
 pub use self::transaction::{Transaction, RichRawTransaction, LocalTransactionStatus};
 pub use self::transaction_request::TransactionRequest;

rpc/src/v1/types/trace.rs

@@ -22,6 +22,7 @@ use ethcore::trace as et;
 use ethcore::state_diff;
 use ethcore::account_diff;
 use ethcore::client::Executed;
+use ethereum_types::H256 as eth_H256;
 use vm;
 use v1::types::{Bytes, H160, H256, U256};
 
@@ -631,6 +632,36 @@ impl From<Executed> for TraceResults {
 	}
 }
 
+#[derive(Debug, Serialize)]
+/// A diff of some chunk of memory.
+pub struct TraceResultsWithTransHash {
+	/// The output of the call/create
+	pub output: Bytes,
+	/// The transaction trace.
+	pub trace: Vec<Trace>,
+	/// The transaction trace.
+	#[serde(rename="vmTrace")]
+	pub vm_trace: Option<VMTrace>,
+	/// The transaction trace.
+	#[serde(rename="stateDiff")]
+	pub state_diff: Option<StateDiff>,
+	/// The transaction Hash.
+	#[serde(rename="TransactionHash")]
+	pub trans_hash: Option<H256>,
+}
+
+impl From<(Option<eth_H256>, Executed)> for TraceResultsWithTransHash {
+	fn from(t: (Option<eth_H256>, Executed)) -> Self {
+		TraceResultsWithTransHash {
+			output: t.1.output.into(),
+			trace: t.1.trace.into_iter().map(Into::into).collect(),
+			vm_trace: t.1.vm_trace.map(Into::into),
+			state_diff: t.1.state_diff.map(Into::into),
+			trans_hash: t.0.map(Into::into),
+		}
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use serde_json;